ctxman 3.1.0 → 3.2.7

package/lib/api/mcp/server.js

@@ -19,11 +19,29 @@ import { PromptProvider } from './prompts.js';
 import { buildPrContext } from '../../pr/pr-context.js';
 import { resolveRootDir, resolveSandboxPath } from './sandbox.js';
 import { searchProject, DEFAULT_LIMIT, DEFAULT_MAX_TOKENS } from '../../search/bm25.js';
+import { hybridSearch } from '../../search/hybrid.js';
 import { getSymbol } from '../../search/symbols.js';
 import { countForModel } from '../../count/index.js';
 import { explainHistory } from '../../why/index.js';
 import { packContext, describePack, TOOL_DEFAULT_BUDGET } from '../../pack/index.js';
-import { loadPolicy, guardExport } from '../../policy/index.js';
+import { focusContext, describeFocus, DEFAULT_FOCUS_DEPTH } from '../../focus/index.js';
+import { mapWorkspace, searchWorkspace, packWorkspace } from '../../workspace/index.js';
+import {
+  loadPolicy,
+  guardExport,
+  PolicyConfigError,
+  auditLogFiles,
+  readAuditLog,
+  filterAuditEvents,
+  parseSince,
+  checkWorkspacePolicies,
+  readWorkspaceAuditLogs,
+} from '../../policy/index.js';
+import { askCodebase, DEFAULT_ASK_LIMIT } from '../../rag/ask.js';
+import { buildTaskContext, DEFAULT_TASK_BUDGET } from '../../task/index.js';
+import { diagnoseFailure, DEFAULT_DIAGNOSE_BUDGET } from '../../diagnose/index.js';
+import { findExperts, DEFAULT_WHO_LIMIT } from '../../who/index.js';
+import { IncrementalAnalyzer } from '../../watch/IncrementalAnalyzer.js';
 import fs from 'fs';
 import path from 'path';
 import { createRequire } from 'module';
@@ -33,6 +51,11 @@ const { version } = createRequire(import.meta.url)('../../../package.json');
 // Tools whose `path` may also name a single file
 const FILE_PATH_TOOLS = new Set(['list_methods']);
 
+const DEFAULT_AUDIT_LIMIT = 50;
+// Characters of each ask_codebase snippet (the index stores whole files)
+const ASK_SNIPPET_CHARS = 2000;
+const DEFAULT_GRAPH_LIMIT = 50;
+
 class MCPServer {
   /**
    * @param {Object} [options]
@@ -56,14 +79,39 @@ class MCPServer {
       }
     );
 
-    this.analyzer = new Analyzer();
+    this.analyzer = new Analyzer({ cache: true });
     this.contextBuilder = new ContextBuilder();
+    this.incrementalAnalyzers = new Map();
     this.resourceProvider = new ResourceProvider(this.root ?? undefined);
     this.promptProvider = new PromptProvider(this.analyzer, this.contextBuilder);
     this.setupHandlers();
     this.setupErrorHandling();
   }
 
+  /**
+   * Get or create a cached IncrementalAnalyzer instance bound to the project's SQLite knowledge graph.
+   * @param {string} projectPath
+   * @returns {IncrementalAnalyzer}
+   */
+  getIncrementalAnalyzer(projectPath, repos = []) {
+    const resolved = path.resolve(projectPath);
+    const extraRepos = Array.isArray(repos)
+      ? repos.filter(Boolean).map((r) => path.resolve(r))
+      : [];
+    const cacheKey = [resolved, ...extraRepos].join('::');
+    let inc = this.incrementalAnalyzers.get(cacheKey);
+    if (!inc) {
+      inc = new IncrementalAnalyzer({
+        projectRoot: resolved,
+        repos: extraRepos,
+        sync: true,
+        hydrateGraphOnStart: false,
+      });
+      this.incrementalAnalyzers.set(cacheKey, inc);
+    }
+    return inc;
+  }
+
   setupHandlers() {
     this.server.setRequestHandler(ListToolsRequestSchema, async () => {
       return {
@@ -123,13 +171,17 @@ class MCPServer {
           {
             name: 'search_code',
             description:
-              'Search source lines by regular expression (default) or plain substring ("semantic" is currently a substring match). "ranked" returns the methods/functions (or 40-line windows) that best match the query words by BM25, with their source.',
+              'Search source lines by regular expression (default) or plain substring. "ranked" returns BM25-ranked methods/chunks; "semantic" runs vector embedding search projected onto chunks (with BM25 fallback); "hybrid" fuses BM25 and semantic embeddings via Reciprocal Rank Fusion (RRF).',
             inputSchema: {
               type: 'object',
               properties: {
                 path: { type: 'string', description: 'Project root' },
                 query: { type: 'string', description: 'Search query' },
-                type: { type: 'string', enum: ['regex', 'semantic', 'ranked'], default: 'regex' },
+                type: {
+                  type: 'string',
+                  enum: ['regex', 'substring', 'semantic', 'ranked', 'hybrid'],
+                  default: 'regex',
+                },
                 limit: {
                   type: 'number',
                   description: `ranked: maximum number of chunks (default ${DEFAULT_LIMIT})`,
@@ -142,6 +194,12 @@ class MCPServer {
                   type: 'boolean',
                   description: 'ranked: redact secrets in the returned source (default true)',
                 },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'ranked/hybrid: additional repository roots to search across under one shared token budget',
+                },
               },
               required: ['path', 'query'],
             },
@@ -182,6 +240,12 @@ class MCPServer {
                   description:
                     'Project-relative files or folders to rank higher, with the files next to them in the import graph',
                 },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots to include in a multi-repository workspace map under one shared token budget',
+                },
               },
               required: ['path'],
             },
@@ -189,7 +253,7 @@ class MCPServer {
           {
             name: 'pr_context',
             description:
-              'Review context for a branch: summary, commit log, changed files, full source of changed methods, unified diff and related tests (secrets redacted)',
+              'Review context for a branch (single-repo or multi-repo workspace): summary, commit log, changed files, full source of changed methods, unified diff and related tests (secrets redacted)',
             inputSchema: {
               type: 'object',
               properties: {
@@ -202,6 +266,12 @@ class MCPServer {
                 head: { type: 'string', description: 'Head branch or commit (default: HEAD)' },
                 budget: { type: 'number', description: 'Maximum tokens of the result' },
                 style: { type: 'string', enum: ['markdown', 'xml', 'json'], default: 'markdown' },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots to include in multi-repository PR review context under one shared token budget',
+                },
               },
               required: ['path'],
             },
@@ -209,7 +279,7 @@ class MCPServer {
           {
             name: 'get_symbol',
             description:
-              'Full source of a method, function or class by name, with file and line range. Exact matches first, then case-insensitive; similar names are suggested when nothing matches. "Class.method" narrows to methods of a class.',
+              'Full source of a method, function or class by name, with file and line range (single-repo or multi-repo workspace). Exact matches first, then case-insensitive; similar names are suggested when nothing matches. "Class.method" narrows to methods of a class.',
             inputSchema: {
               type: 'object',
               properties: {
@@ -217,12 +287,19 @@ class MCPServer {
                 name: { type: 'string', description: 'Symbol name, or Class.method' },
                 file: {
                   type: 'string',
-                  description: 'Optional: only look in this project-relative file',
+                  description:
+                    'Optional: only look in this project-relative (or <alias>/<path>) file',
                 },
                 redact: {
                   type: 'boolean',
                   description: 'Redact secrets in the source (default true)',
                 },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots to search for symbols across under one shared token budget',
+                },
               },
               required: ['path', 'name'],
             },
@@ -253,7 +330,7 @@ class MCPServer {
           {
             name: 'explain_history',
             description:
-              'Explain why code looks the way it does, from the local git history (offline): commits that changed a file, symbol or line range with their messages, referenced issues/PRs/tickets, blame ownership, files that change together with it, related docs/ADRs/comments, TODO notes and tests. Returns Markdown.',
+              'Explain why code looks the way it does, from the local git history (offline, single-repo or multi-repo workspace): commits that changed a file, symbol or line range with their messages, referenced issues/PRs/tickets, institutional memory citations (.plansmith/analyzer.sqlite), blame ownership, files that change together with it, related docs/ADRs/comments, TODO notes and tests. Returns Markdown.',
             inputSchema: {
               type: 'object',
               properties: {
@@ -264,7 +341,7 @@ class MCPServer {
                 target: {
                   type: 'string',
                   description:
-                    'File relative to path, optionally with a symbol or line range: "src/cart.js", "src/cart.js:total", "src/cart.js:Cart.total", "src/cart.js#L10-L40"',
+                    'File relative to path (or <alias>/<path> in multi-repo mode), optionally with a symbol or line range: "src/cart.js", "src/cart.js:total", "src/cart.js:Cart.total", "src/cart.js#L10-L40"',
                 },
                 limit: {
                   type: 'number',
@@ -283,6 +360,32 @@ class MCPServer {
                   type: 'boolean',
                   description: "Include each commit's diff of the target (default false)",
                 },
+                discussions: {
+                  type: 'boolean',
+                  description:
+                    'Fetch referenced GitHub/GitLab issue, PR and MR discussions over HTTPS (default false; uses GITHUB_TOKEN/GH_TOKEN or GITLAB_TOKEN when set)',
+                },
+                maxDiscussions: {
+                  type: 'number',
+                  description:
+                    'Maximum remote discussions to fetch when discussions is true (default 10)',
+                },
+                analyzer: {
+                  type: 'boolean',
+                  description:
+                    'Query local @plansmithai/analyzer SQLite database (.plansmith/analyzer.sqlite) for institutional memory citations',
+                },
+                analyzerDb: {
+                  type: 'string',
+                  description:
+                    'Explicit path to @plansmithai/analyzer SQLite database file or directory',
+                },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots to include in multi-repository history explanation and cross-repo ADR/doc/test discovery',
+                },
               },
               required: ['path', 'target'],
             },
@@ -336,6 +439,288 @@ class MCPServer {
                   type: 'string',
                   description: "Count with this model's tokenizer encoding and report the fit",
                 },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots to pack into one workspace document under one shared token budget',
+                },
+              },
+              required: ['path'],
+            },
+          },
+          {
+            name: 'focus_context',
+            description:
+              'Focused neighborhood context around a target file (or file:symbol): packs the target file together with its outgoing imports/callees and incoming importers/callers up to `depth` hops in the repository import and AST symbol call graph (directional traversal avoids shared-hub explosion), honouring .gitignore/.contextignore and export policy, with secrets redacted and trimmed to a token budget (target file kept first).',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                path: { type: 'string', description: 'Project root' },
+                file: {
+                  type: 'string',
+                  description:
+                    'Project-relative (or <alias>/<path>) file or file:symbol to focus on (e.g. "src/auth/login.ts" or "src/auth/login.ts:authenticate")',
+                },
+                symbol: {
+                  type: 'string',
+                  description:
+                    'Optional function or method name inside `file` to traverse the cross-file AST symbol call graph around',
+                },
+                depth: {
+                  type: 'number',
+                  description: `Import/call graph hops (default ${DEFAULT_FOCUS_DEPTH}; 0 = target file only)`,
+                },
+                direction: {
+                  type: 'string',
+                  enum: ['both', 'imports', 'importers', 'calls', 'callers'],
+                  default: 'both',
+                },
+                callGraph: {
+                  type: 'boolean',
+                  description:
+                    'Include cross-file AST symbol call graph edges alongside module imports (default true)',
+                },
+                includeTests: {
+                  type: 'boolean',
+                  description: 'Include test files in the neighborhood (default true)',
+                },
+                style: {
+                  type: 'string',
+                  enum: ['xml', 'markdown', 'plain', 'json'],
+                  default: 'xml',
+                },
+                compress: {
+                  type: 'boolean',
+                  description: 'Keep signatures, replace function bodies with a placeholder',
+                },
+                lineNumbers: { type: 'boolean', description: 'Number every line' },
+                tree: {
+                  type: 'boolean',
+                  description: 'Directory tree at the top (default true)',
+                },
+                instructions: {
+                  type: 'string',
+                  description: 'Text placed at the end, after the files',
+                },
+                budget: {
+                  type: 'number',
+                  description: `Maximum tokens of the document (default ${TOOL_DEFAULT_BUDGET})`,
+                },
+                targetModel: {
+                  type: 'string',
+                  description: "Count with this model's tokenizer encoding and report the fit",
+                },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots to include in the workspace import/call graph neighborhood under one shared token budget',
+                },
+              },
+              required: ['path', 'file'],
+            },
+          },
+          {
+            name: 'check_policy',
+            description:
+              'The effective export policy of a project or multi-repository workspace (.ctxman/policy.json plus the organisation policy named by CTXMAN_POLICY): denied paths, redaction and token limits, allowed target models, AI-tool ignore files and audit logging. Reports whether the policy files are valid and, if not, every error.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                path: { type: 'string', description: 'Project root' },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots to validate and summarize together in a multi-repository workspace',
+                },
+              },
+              required: ['path'],
+            },
+          },
+          {
+            name: 'audit_log',
+            description:
+              "Exports recorded in the project's (or multi-repository workspace's) audit log while the export policy enables audit: when, by whom, which command, where to, which files, token count and a SHA-256 of the exported text. Newest last.",
+            inputSchema: {
+              type: 'object',
+              properties: {
+                path: { type: 'string', description: 'Project root' },
+                since: {
+                  type: 'string',
+                  description:
+                    'Only exports at or after this date (2026-10-01), ISO time or age (30m, 12h, 7d, 2w)',
+                },
+                limit: {
+                  type: 'number',
+                  description: `The last N events (default ${DEFAULT_AUDIT_LIMIT}; 0 = all)`,
+                },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots whose export audit logs should be merged chronologically with repo attribution',
+                },
+              },
+              required: ['path'],
+            },
+          },
+          {
+            name: 'ask_codebase',
+            description:
+              'Semantic search: the files whose content is closest in meaning to a question, from a local SQLite embedding index (.ctxman/self-knowledge/index.sqlite via built-in node:sqlite, single-repo or multi-repo workspace). Uses @xenova/transformers when installed and automatically falls back to deterministic offline LocalHashEmbeddingProvider otherwise. For exact names or keywords, search_code is faster.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                path: { type: 'string', description: 'Project root' },
+                query: { type: 'string', description: 'The question, in natural language' },
+                limit: {
+                  type: 'number',
+                  description: `How many files (default ${DEFAULT_ASK_LIMIT})`,
+                },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots to include in multi-repository semantic search',
+                },
+              },
+              required: ['path', 'query'],
+            },
+          },
+          {
+            name: 'task_context',
+            description:
+              'Task-driven automatic context builder: fuses hybrid search, PageRank import/call neighborhood, and architectural map for a task description within a token budget (single-repo or multi-repo workspace).',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                path: { type: 'string', description: 'Project root' },
+                task: { type: 'string', description: 'Natural-language task or issue description' },
+                budget: {
+                  type: 'number',
+                  description: `Maximum tokens (default ${DEFAULT_TASK_BUDGET})`,
+                },
+                format: { type: 'string', enum: ['xml', 'markdown', 'json'], default: 'xml' },
+                model: { type: 'string', description: 'Optional target LLM model ID' },
+                callGraph: {
+                  type: 'boolean',
+                  description:
+                    'Include cross-file AST symbol call graph edges alongside module imports (default true)',
+                },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots to include in a multi-repository task context bundle under one shared token budget',
+                },
+              },
+              required: ['path', 'task'],
+            },
+          },
+          {
+            name: 'diagnose_failure',
+            description:
+              'Diagnose a stack trace, test failure, or error log: parses implicated repo files/lines (single-repo or multi-repo workspace), packs enclosing symbols and 1-hop graph neighbors, and surfaces recent commits that touched them.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                path: { type: 'string', description: 'Project root' },
+                trace: { type: 'string', description: 'Error stack trace or failure log text' },
+                budget: {
+                  type: 'number',
+                  description: `Maximum tokens (default ${DEFAULT_DIAGNOSE_BUDGET})`,
+                },
+                format: { type: 'string', enum: ['xml', 'markdown', 'json'], default: 'xml' },
+                callGraph: {
+                  type: 'boolean',
+                  description:
+                    'Include cross-file AST symbol call graph edges alongside module imports (default true)',
+                },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots to resolve stack frames and 1-hop neighbors across under one shared token budget',
+                },
+              },
+              required: ['path', 'trace'],
+            },
+          },
+          {
+            name: 'find_experts',
+            description:
+              'Expert Finder ("Who knows about this?"): ranks code and domain experts for a file, symbol, directory, or natural-language topic (single-repo or multi-repo workspace) by fusing surviving git blame ownership, recency-decayed commit/churn history, and CODEOWNERS stewardship.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                path: { type: 'string', description: 'Project root inside a git repository' },
+                target: {
+                  type: 'string',
+                  description:
+                    'File path (<alias>/<path>), file:symbol, file#L10-L40, directory, or natural-language topic query',
+                },
+                limit: {
+                  type: 'number',
+                  description: `Maximum ranked experts to return (default ${DEFAULT_WHO_LIMIT})`,
+                },
+                halfLifeDays: {
+                  type: 'number',
+                  description: 'Recency exponential decay half-life in days (default 90)',
+                },
+                style: {
+                  type: 'string',
+                  enum: ['markdown', 'xml', 'json'],
+                  default: 'markdown',
+                },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots inside git repositories to include in multi-repository expert ranking',
+                },
+              },
+              required: ['path', 'target'],
+            },
+          },
+          {
+            name: 'query_knowledge_graph',
+            description:
+              'Query the persistent SQLite knowledge graph (.ctxman/self-knowledge/index.sqlite) or IncrementalAnalyzer cache for file nodes, method declarations, and import/dependency edges.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                path: { type: 'string', description: 'Project root' },
+                query: {
+                  type: 'string',
+                  description:
+                    'Optional substring or symbol query to filter graph nodes and method declarations',
+                },
+                file: {
+                  type: 'string',
+                  description:
+                    'Optional project-relative file path to inspect along with its dependency neighborhood',
+                },
+                depth: {
+                  type: 'number',
+                  description: 'Neighborhood hop depth when file is provided (default: 1, max: 4)',
+                },
+                limit: {
+                  type: 'number',
+                  description: `Maximum number of graph nodes to return (default ${DEFAULT_GRAPH_LIMIT})`,
+                },
+                refresh: {
+                  type: 'boolean',
+                  description:
+                    'Re-synchronize the IncrementalAnalyzer cache and SQLite knowledge graph before querying',
+                },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Optional additional repository roots to include in a multi-repository knowledge graph under <alias>/<path>',
+                },
               },
               required: ['path'],
             },
@@ -405,6 +790,21 @@ class MCPServer {
             }),
           };
         }
+        if (args.repos !== undefined) {
+          if (!Array.isArray(args.repos)) {
+            throw new Error('repos must be an array of directory paths');
+          }
+          args = {
+            ...args,
+            repos: args.repos.map((repoPath) =>
+              resolveSandboxPath(repoPath, {
+                root: this.root,
+                expect: 'directory',
+                name: 'repos',
+              })
+            ),
+          };
+        }
 
         switch (name) {
           case 'analyze_codebase': {
@@ -502,6 +902,17 @@ class MCPServer {
           }
           case 'search_code': {
             const { path: projectPath, query, type = 'regex' } = args;
+            if (
+              args.repos?.length > 0 &&
+              (type === 'ranked' || type === 'hybrid' || type === 'semantic')
+            ) {
+              const result = searchWorkspace([projectPath, ...args.repos], query, {
+                limit: args.limit ?? DEFAULT_LIMIT,
+                maxTokens: args.maxTokens ?? DEFAULT_MAX_TOKENS,
+                redact: args.redact !== false,
+              });
+              return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
             if (type === 'ranked') {
               const result = searchProject(projectPath, query, {
                 limit: args.limit ?? DEFAULT_LIMIT,
@@ -510,6 +921,16 @@ class MCPServer {
               });
               return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
             }
+            if (type === 'hybrid' || type === 'semantic') {
+              const result = await hybridSearch(projectPath, query, {
+                mode: type,
+                fallbackToBm25: true,
+                limit: args.limit ?? DEFAULT_LIMIT,
+                maxTokens: args.maxTokens ?? DEFAULT_MAX_TOKENS,
+                redact: args.redact !== false,
+              });
+              return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
             let pattern = null;
             if (type === 'regex') {
               try {
@@ -572,7 +993,7 @@ class MCPServer {
             }
 
             // Use Analyzer with methodLevel: true
-            const methodAnalyzer = new Analyzer({ methodLevel: true });
+            const methodAnalyzer = new Analyzer({ methodLevel: true, cache: true });
             const analysis = await methodAnalyzer.analyze(files);
 
             const methods = [];
@@ -592,10 +1013,18 @@ class MCPServer {
             };
           }
           case 'repo_map': {
-            const map = renderRepoMap(args.path, {
-              tokens: args.tokens,
-              focus: args.focus,
-            });
+            const map =
+              args.repos?.length > 0
+                ? mapWorkspace([args.path, ...args.repos], {
+                    tokens: args.tokens,
+                    focus: args.focus,
+                    callGraph: args.callGraph,
+                  })
+                : renderRepoMap(args.path, {
+                    tokens: args.tokens,
+                    focus: args.focus,
+                    callGraph: args.callGraph,
+                  });
             const notes = map.warnings.map((warning) => `Note: ${warning}`).join('\n');
             return {
               content: [
@@ -608,6 +1037,7 @@ class MCPServer {
           }
           case 'pr_context': {
             const result = await buildPrContext(args.path, {
+              repos: args.repos,
               base: args.base,
               head: args.head,
               budget: args.budget == null ? undefined : Math.floor(args.budget),
@@ -619,6 +1049,7 @@ class MCPServer {
             const result = getSymbol(args.path, args.name, {
               file: args.file,
               redact: args.redact !== false,
+              repos: args.repos,
             });
             return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
           }
@@ -636,15 +1067,47 @@ class MCPServer {
           }
           case 'explain_history': {
             const whole = (value) => (typeof value === 'number' ? Math.floor(value) : value);
+            const analyzerDb =
+              args.analyzerDb !== undefined
+                ? resolveSandboxPath(args.analyzerDb, {
+                    root: this.root,
+                    expect: 'any',
+                    name: 'analyzerDb',
+                  })
+                : undefined;
             const result = await explainHistory(args.path, args.target, {
+              repos: args.repos,
               limit: whole(args.limit),
               budget: whole(args.budget ?? 20000),
               since: args.since,
               patches: args.patches === true,
+              discussions: args.discussions === true,
+              maxDiscussions: whole(args.maxDiscussions),
+              analyzer: args.analyzer === true,
+              analyzerDb,
             });
             return { content: [{ type: 'text', text: result.text }] };
           }
           case 'pack_context': {
+            if (args.repos?.length > 0) {
+              const result = await packWorkspace([args.path, ...args.repos], {
+                include: args.include,
+                exclude: args.exclude,
+                style: args.style,
+                compress: args.compress,
+                lineNumbers: args.lineNumbers,
+                tree: args.tree,
+                instructions: args.instructions,
+                budget: args.budget == null ? TOOL_DEFAULT_BUDGET : Math.floor(args.budget),
+                targetModel: args.targetModel,
+              });
+              return {
+                content: [
+                  { type: 'text', text: result.text },
+                  { type: 'text', text: describePack(result) },
+                ],
+              };
+            }
             const result = await packContext(args.path, {
               include: args.include,
               exclude: args.exclude,
@@ -666,6 +1129,242 @@ class MCPServer {
               ],
             };
           }
+          case 'focus_context': {
+            const result = await focusContext(args.path, args.file ?? args.target, {
+              repos: args.repos,
+              symbol: args.symbol,
+              depth: args.depth == null ? undefined : Math.floor(args.depth),
+              direction: args.direction,
+              callGraph: args.callGraph,
+              includeTests: args.includeTests,
+              cwd: args.path,
+              style: args.style,
+              compress: args.compress,
+              lineNumbers: args.lineNumbers,
+              tree: args.tree,
+              instructions: args.instructions,
+              budget: args.budget == null ? TOOL_DEFAULT_BUDGET : Math.floor(args.budget),
+              targetModel: args.targetModel,
+            });
+            return {
+              content: [
+                { type: 'text', text: result.text },
+                { type: 'text', text: describeFocus(result) },
+              ],
+            };
+          }
+          case 'check_policy': {
+            if (args.repos?.length > 0) {
+              const result = checkWorkspacePolicies(args.path, args.repos);
+              return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            let result;
+            try {
+              result = { valid: true, ...loadPolicy(args.path).toJSON() };
+            } catch (error) {
+              if (!(error instanceof PolicyConfigError)) throw error;
+              result = { valid: false, file: error.file, errors: error.errors };
+            }
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+          }
+          case 'audit_log': {
+            const since = args.since === undefined ? null : parseSince(String(args.since));
+            const limit =
+              Number.isInteger(args.limit) && args.limit >= 0 ? args.limit : DEFAULT_AUDIT_LIMIT;
+            if (args.repos?.length > 0) {
+              const ws = readWorkspaceAuditLogs(args.path, args.repos, { since, limit });
+              const result = {
+                repos: ws.repos,
+                files: ws.files,
+                total: ws.total,
+                events: ws.events,
+                skippedLines: ws.skippedLines,
+              };
+              if (ws.policyErrors.length > 0) result.policyErrors = ws.policyErrors;
+              return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            // Only the policy's own logs: a tool argument never names a file to read
+            const { files, error } = auditLogFiles(args.path);
+            const { events, skipped, missing } = readAuditLog(files);
+            const matching = filterAuditEvents(events, { since });
+            const result = {
+              files: files.filter((file) => !missing.includes(file)),
+              total: matching.length,
+              events: filterAuditEvents(matching, { limit }),
+              skippedLines: skipped,
+            };
+            if (error) result.policyError = error.message;
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+          }
+          case 'ask_codebase': {
+            const result = await askCodebase(args.path, args.query, {
+              repos: args.repos,
+              limit: Number.isInteger(args.limit) ? args.limit : undefined,
+              maxChars: ASK_SNIPPET_CHARS,
+            });
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+          }
+          case 'task_context': {
+            const result = await buildTaskContext(
+              args.path ?? args.dir ?? process.cwd(),
+              args.task ?? args.query ?? '',
+              {
+                repos: args.repos,
+                budget: args.budget == null ? DEFAULT_TASK_BUDGET : Math.floor(args.budget),
+                format: args.format,
+                model: args.model,
+                callGraph: args.callGraph,
+              }
+            );
+            return {
+              content: [
+                { type: 'text', text: result.text },
+                {
+                  type: 'text',
+                  text: `Task Context: ${result.files.length} file(s), ${result.totalTokens}/${result.budget} tokens (${result.format}).`,
+                },
+              ],
+            };
+          }
+          case 'diagnose_failure': {
+            const result = await diagnoseFailure(
+              args.path ?? args.dir ?? process.cwd(),
+              args.trace ?? args.log ?? '',
+              {
+                repos: args.repos,
+                budget: args.budget == null ? DEFAULT_DIAGNOSE_BUDGET : Math.floor(args.budget),
+                format: args.format,
+                callGraph: args.callGraph,
+              }
+            );
+            return {
+              content: [
+                { type: 'text', text: result.text },
+                {
+                  type: 'text',
+                  text: `Diagnosed: ${result.implicatedFiles.length} implicated file(s), ${result.totalTokens}/${result.budget} tokens.`,
+                },
+              ],
+            };
+          }
+          case 'find_experts': {
+            const result = await findExperts(
+              args.path ?? process.cwd(),
+              args.target ?? args.query ?? '',
+              {
+                repos: args.repos,
+                limit: Number.isInteger(args.limit) ? args.limit : undefined,
+                halfLifeDays: typeof args.halfLifeDays === 'number' ? args.halfLifeDays : undefined,
+                style: args.style || 'markdown',
+              }
+            );
+            return {
+              content: [{ type: 'text', text: result.text }],
+            };
+          }
+          case 'query_knowledge_graph': {
+            const projectPath = args.path ?? process.cwd();
+            const extraRepos = Array.isArray(args.repos) ? args.repos : [];
+            const scanner = new Scanner(projectPath);
+            scanner.getPolicy();
+            for (const repoPath of extraRepos) {
+              new Scanner(repoPath).getPolicy();
+            }
+
+            const inc = this.getIncrementalAnalyzer(projectPath, extraRepos);
+            await inc.ensureSyncReady(projectPath);
+            const store = inc.vectorStore;
+            const initialCounts = store.graphCounts();
+
+            let bootstrapped = false;
+            if (args.refresh === true || initialCounts.nodes === 0) {
+              await inc.bootstrapSync(projectPath, { repos: extraRepos });
+              bootstrapped = true;
+            }
+
+            const rawGraph = await inc.getGraph();
+            let nodes = rawGraph.nodes.filter((n) => !inc.isPathDenied(n.path));
+            let edges = rawGraph.edges.filter(
+              (e) => !inc.isPathDenied(e.from) && !inc.isPathDenied(e.to)
+            );
+
+            if (typeof args.file === 'string' && args.file.trim()) {
+              const targetFile = args.file.trim().replace(/\\/g, '/').replace(/^\.\//, '');
+              const maxDepth = Math.max(
+                1,
+                Math.min(4, Number.isFinite(args.depth) ? Math.floor(args.depth) : 1)
+              );
+              const visited = new Set([targetFile]);
+              let frontier = new Set([targetFile]);
+
+              for (let hop = 0; hop < maxDepth && frontier.size > 0; hop++) {
+                const nextFrontier = new Set();
+                for (const edge of edges) {
+                  if (frontier.has(edge.from) && !visited.has(edge.to)) {
+                    visited.add(edge.to);
+                    nextFrontier.add(edge.to);
+                  }
+                  if (frontier.has(edge.to) && !visited.has(edge.from)) {
+                    visited.add(edge.from);
+                    nextFrontier.add(edge.from);
+                  }
+                }
+                frontier = nextFrontier;
+              }
+
+              nodes = nodes.filter((n) => visited.has(n.path));
+              edges = edges.filter((e) => visited.has(e.from) && visited.has(e.to));
+            }
+
+            if (typeof args.query === 'string' && args.query.trim()) {
+              const needle = args.query.trim().toLowerCase();
+              nodes = nodes.filter((n) => {
+                if (n.path.toLowerCase().includes(needle)) return true;
+                if (Array.isArray(n.methods)) {
+                  return n.methods.some((m) => {
+                    const name = typeof m === 'string' ? m : m?.name || '';
+                    const sig = typeof m === 'object' ? m?.signature || '' : '';
+                    return (
+                      name.toLowerCase().includes(needle) || sig.toLowerCase().includes(needle)
+                    );
+                  });
+                }
+                return false;
+              });
+              const matchedPaths = new Set(nodes.map((n) => n.path));
+              edges = edges.filter((e) => matchedPaths.has(e.from) || matchedPaths.has(e.to));
+            }
+
+            const limit = Math.max(
+              1,
+              Math.min(
+                500,
+                Number.isFinite(args.limit) ? Math.floor(args.limit) : DEFAULT_GRAPH_LIMIT
+              )
+            );
+            const limitedNodes = nodes.slice(0, limit);
+            const keptPaths = new Set(limitedNodes.map((n) => n.path));
+            const matchingEdges = edges.filter((e) => keptPaths.has(e.from) || keptPaths.has(e.to));
+
+            const counts = store.graphCounts();
+            const payload = {
+              path: projectPath,
+              bootstrapped,
+              cached: inc.fileCache.size > 0 || inc.graphNodes.size > 0,
+              stats: {
+                totalNodes: counts.nodes,
+                totalEdges: counts.edges,
+                vectorDocuments: store.count(),
+                cachedFiles: inc.fileCache.size,
+              },
+              nodes: limitedNodes,
+              edges: matchingEdges,
+            };
+
+            return {
+              content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+            };
+          }
           default:
             throw new Error(`Unknown tool: ${name}`);
         }