merge: AgentProject membership — the junction is now load-bearing

Merges feat/agent-project-membership (task 166/152). An agent can finally join
many projects: membership routes, per-membership role and optional brain
override, chat resolving context from the membership, and CLI attach-agent /
detach-agent / get memberships. The legacy Agent.projectId fallback is kept for
this release as the schema comment promises.

Conflict resolved in main.ts: that branch added its RBAC case to
mapUrlToPermission inline, while this branch had extracted the function to
middleware/url-permission.ts so it could be tested. Kept the extraction and
ported the case into it — joining a team is `edit:agents:<name>`, not
`create:agents`, which is the authority to mint a whole agent.

Also fixes something the extraction makes possible. security.test.ts contained a
hand-copied reproduction of mapUrlToPermission, because main.ts self-invokes
main() and nothing in it was importable. A security test asserting against a
copy stops testing the system the moment the real one changes, and this copy had
already drifted. It now imports the real function; all 18 assertions still pass,
against the code that actually runs.

Local: build clean, workspace 2550 passed, lint unchanged at 794 errors.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01N4wNHWf7xSwnZCWpJcyv9p

.taskmaster/tasks/task_029.md

@@ -0,0 +1,74 @@
+# Task ID: 29
+
+**Title:** Implement LLM pre-processing pipeline in mcplocal
+
+**Status:** done
+
+**Dependencies:** 25 ✓, 27 ✓, 28 ✓
+
+**Priority:** high
+
+**Description:** Create the core LLM pre-processing pipeline that intercepts MCP tool calls, uses a local LLM to optimize requests before sending to mcpd, and filters responses before returning to Claude.
+
+**Details:**
+
+1. Create `src/mcplocal/src/llm/processor.ts` - the core pipeline:
+   ```typescript
+   export class LlmProcessor {
+     constructor(
+       private providerRegistry: ProviderRegistry,
+       private config: LlmProcessorConfig
+     ) {}
+     
+     async preprocessRequest(toolName: string, params: unknown): Promise<ProcessedRequest> {
+       // Use LLM to interpret and optimize the request
+       const prompt = this.buildRequestPrompt(toolName, params);
+       const result = await this.providerRegistry.getActiveProvider().complete({
+         systemPrompt: REQUEST_OPTIMIZATION_SYSTEM_PROMPT,
+         userPrompt: prompt
+       });
+       return this.parseOptimizedRequest(result);
+     }
+     
+     async filterResponse(toolName: string, originalRequest: unknown, rawResponse: unknown): Promise<FilteredResponse> {
+       // Use LLM to filter/summarize the response
+       const prompt = this.buildFilterPrompt(toolName, originalRequest, rawResponse);
+       const result = await this.providerRegistry.getActiveProvider().complete({
+         systemPrompt: RESPONSE_FILTER_SYSTEM_PROMPT,
+         userPrompt: prompt
+       });
+       return this.parseFilteredResponse(result);
+     }
+   }
+   ```
+2. Create system prompts in `src/mcplocal/src/llm/prompts.ts`:
+   - REQUEST_OPTIMIZATION_SYSTEM_PROMPT: instruct LLM to generate optimal queries
+   - RESPONSE_FILTER_SYSTEM_PROMPT: instruct LLM to extract relevant information
+3. Integrate into router.ts - wrap tools/call handler:
+   ```typescript
+   async handleToolsCall(request: JsonRpcRequest) {
+     if (this.shouldPreprocess(request.params.name)) {
+       const processed = await this.llmProcessor.preprocessRequest(...);
+       // Call mcpd with processed request
+       const rawResponse = await this.callMcpd(processed);
+       const filtered = await this.llmProcessor.filterResponse(...);
+       return filtered;
+     }
+     return this.callMcpd(request.params);
+   }
+   ```
+4. Add configuration options:
+   - `enablePreprocessing`: boolean
+   - `preprocessingExclude`: string[] (tool names to skip)
+   - `preferredProvider`: string (ollama, gemini, deepseek, etc.)
+5. Add bypass logic for simple operations (list, create, delete)
+
+**Test Strategy:**
+
+1. Unit test: Request preprocessing generates optimized queries
+2. Unit test: Response filtering reduces data volume
+3. Unit test: Bypass logic works for excluded tools
+4. Integration test: Full pipeline with mock LLM provider
+5. Test error handling: LLM failure falls back to unfiltered pass-through
+6. Test configuration options are respected
+7. Measure: response size reduction percentage