@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/dist/mcp/server.js

@@ -0,0 +1,1208 @@
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { finalizeToolResult, finalizeToolResultWithDelivery, renderToolText as toolText, stripResultDetails } from "../tools/render-compact.js";
+import { AstGrepClient } from "../clients/ast-grep-client.js";
+import { CacheManager } from "../clients/cache-manager.js";
+import { getDegradationSummary, recordDegradationOnce, renderDegradationLines } from "../clients/degradation-ledger.js";
+import { acknowledgeTurnEnd, analyzeFile, analyzeFileFresh, canRebuildDmLens, createMcpHost, createWarmIpcLineReader, createWarmIpcRequestQueue, diagnosticStats, effectiveConfig, ensureLspConfig, generatedSkipNotice, ipcPathForCwd, isEffectiveFileViewError, lspStatus, moduleReport, projectReport, projectScan, readEnclosing, readSymbol, readTurnEndStatus, recentLatency, renderCompactModuleReport, renderCompactProjectReport, renderLspBrokenStatusLines, resolveRebuildScript, resourceFootprint, runRebuild, runSessionStart, runTurnEnd, runTurnEndForIpc, scanTruncationNotice, summarizeScan, symbolSearch, treeSitterRuntimeStatus, WARM_TURN_END_SCHEMA_VERSION } from "../clients/lens-engine.js";
+import { createAstGrepReplaceTool } from "../tools/ast-grep-replace.js";
+import { astGrepDumpCompatibilityResult, createAstGrepSearchTool } from "../tools/ast-grep-search.js";
+import { createLensDiagnosticsTool } from "../tools/lens-diagnostics.js";
+import { peekMcpSessionRuntime } from "../clients/mcp/session.js";
+import { loadDmLensGlobalConfig } from "../clients/lens-config.js";
+import { loadDmLensProjectConfig } from "../clients/project-lens-config.js";
+import { resolveLensToolEnabled, toolRegistryEntryForMcp } from "../clients/tool-config.js";
+import { endSituationalToolTelemetry, observeSituationalToolCall, startSituationalToolTelemetrySession } from "../clients/situational-tool-telemetry.js";
+import { flushExtensionLog } from "../clients/extension-log.js";
+import { createLspNavigationTool } from "../tools/lsp-navigation.js";
+import { shouldInitializeSessionRoot } from "../clients/lsp/session-roots.js";
+import { computeBuildStamp, STALE_SERVED_BY_FRESH, STALE_WARN_ONLY, StalenessGate, stalenessCheckEnabled } from "./build-staleness.js";
+console.log = (...args) => {
+  console.error(...args);
+};
+const SERVER_NAME = "dm-lens-mcp";
+const SERVER_VERSION = "0.1.0";
+const FALLBACK_PROTOCOL_VERSION = "2025-06-18";
+function resolveDefaultCwd() {
+  const fromArg = process.argv.find((arg) => arg.startsWith("--cwd="))?.slice("--cwd=".length);
+  return fromArg ?? process.env.DM_LENS_MCP_CWD ?? process.cwd();
+}
+const DEFAULT_CWD = path.resolve(resolveDefaultCwd());
+const lspReadyCwds = new Set;
+const SERVER_FILE = fileURLToPath(import.meta.url);
+const SERVER_DIR = path.dirname(SERVER_FILE);
+const WORKER_PATH = path.join(SERVER_DIR, "worker.js");
+const REBUILD_SCRIPT = resolveRebuildScript(SERVER_FILE);
+const STALENESS_STAT_PATH = process.env.DM_LENS_MCP_STALENESS_STAT_PATH ?? SERVER_FILE;
+const BUILD_STAMP = computeBuildStamp(STALENESS_STAT_PATH);
+const stalenessIntervalOverride = (() => {
+  const raw = process.env.DM_LENS_MCP_STALENESS_INTERVAL_MS;
+  if (raw === undefined)
+    return;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+})();
+const STALENESS_GATE = new StalenessGate(BUILD_STAMP, {
+  checkIntervalMs: stalenessIntervalOverride
+});
+function isWarmBuildStale() {
+  if (!stalenessCheckEnabled())
+    return false;
+  return STALENESS_GATE.isStale();
+}
+function findRepoRoot(start) {
+  let dir = start;
+  for (let depth = 0;depth < 6; depth++) {
+    const pkgPath = path.join(dir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        if (pkg.name === "dm-lens")
+          return dir;
+      } catch {}
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return path.resolve(start, "..", "..");
+}
+const REPO_ROOT = process.env.DM_LENS_MCP_REPO_ROOT ? path.resolve(process.env.DM_LENS_MCP_REPO_ROOT) : findRepoRoot(SERVER_DIR);
+async function ensureReady(cwd) {
+  const normalized = path.resolve(cwd);
+  if (!shouldInitializeSessionRoot(normalized, lspReadyCwds)) {
+    return;
+  }
+  try {
+    await ensureLspConfig(normalized);
+  } catch (err) {
+    console.error(`[dm-lens-mcp] initLSPConfig failed for ${normalized}: ${err}`);
+  }
+  lspReadyCwds.add(normalized);
+}
+let autoSessionState = {
+  attempted: false,
+  succeeded: false,
+  firedAt: null,
+  error: null
+};
+let autoSessionInFlight = null;
+function maybeAutoSessionStart() {
+  if (process.env.DM_LENS_MCP_AUTO_SESSION !== "1")
+    return;
+  if (autoSessionInFlight || autoSessionState.succeeded)
+    return;
+  autoSessionState = {
+    attempted: true,
+    succeeded: false,
+    firedAt: new Date().toISOString(),
+    error: null
+  };
+  autoSessionInFlight = ensureReady(DEFAULT_CWD).then(() => runSessionStart(DEFAULT_CWD)).then(() => {
+    autoSessionState = { ...autoSessionState, succeeded: true };
+    console.error("[dm-lens-mcp] auto session_start complete");
+  }).catch((err) => {
+    autoSessionState = { ...autoSessionState, error: String(err) };
+    console.error(`[dm-lens-mcp] auto session_start failed: ${err}`);
+  }).finally(() => {
+    autoSessionInFlight = null;
+  });
+}
+function getAutoSessionStatus() {
+  if (process.env.DM_LENS_MCP_AUTO_SESSION !== "1")
+    return null;
+  return { ...autoSessionState };
+}
+const IPC_PATH = ipcPathForCwd(DEFAULT_CWD);
+function rejectForeignTurnCwd(route, cwd) {
+  const message = `${route} cwd outside this server's workspace: ${path.resolve(cwd)} not within ${DEFAULT_CWD}`;
+  console.error(`[dm-lens-mcp] rejected ${message}`);
+  return message;
+}
+function isWithinServerWorkspace(cwd) {
+  const target = path.resolve(cwd);
+  const rel = path.relative(DEFAULT_CWD, target);
+  return !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+function startIpcServer() {
+  if (process.platform !== "win32") {
+    try {
+      fs.unlinkSync(IPC_PATH);
+    } catch {}
+  }
+  const requestQueue = createWarmIpcRequestQueue();
+  const ipc = net.createServer((socket) => {
+    socket.setEncoding("utf8");
+    socket.on("data", createWarmIpcLineReader((line) => {
+      requestQueue.enqueue(async () => {
+        try {
+          if (isWarmBuildStale()) {
+            console.error("[dm-lens-mcp] warm request: build stale, replying with an error");
+            socket.end(`${JSON.stringify({ error: "warm build stale" })}
+`);
+            return;
+          }
+          const parsed = JSON.parse(line);
+          if (parsed.route === "turn-end-ack") {
+            if (parsed.version !== WARM_TURN_END_SCHEMA_VERSION || typeof parsed.deliveryId !== "string") {
+              socket.end(`${JSON.stringify({ error: `turn-end ack schema ${parsed.version} != ${WARM_TURN_END_SCHEMA_VERSION}` })}
+`);
+              return;
+            }
+            const turnCwd = parsed.cwd ?? DEFAULT_CWD;
+            if (!isWithinServerWorkspace(turnCwd)) {
+              socket.end(`${JSON.stringify({ error: rejectForeignTurnCwd("turn-end-ack", turnCwd) })}
+`);
+              return;
+            }
+            const acknowledged = acknowledgeTurnEnd(turnCwd, parsed.deliveryId);
+            socket.end(`${JSON.stringify({
+              result: {
+                route: "turn-end-ack",
+                version: WARM_TURN_END_SCHEMA_VERSION,
+                acknowledged
+              }
+            })}
+`);
+            return;
+          }
+          if (parsed.route === "turn-end") {
+            if (parsed.version !== WARM_TURN_END_SCHEMA_VERSION) {
+              socket.end(`${JSON.stringify({ error: `turn-end schema ${parsed.version} != ${WARM_TURN_END_SCHEMA_VERSION}` })}
+`);
+              return;
+            }
+            const turnCwd = parsed.cwd ?? DEFAULT_CWD;
+            if (!isWithinServerWorkspace(turnCwd)) {
+              socket.end(`${JSON.stringify({ error: rejectForeignTurnCwd("turn-end", turnCwd) })}
+`);
+              return;
+            }
+            if (socket.destroyed) {
+              console.error(`[dm-lens-mcp] warm turn-end: client gone before the pass started (${turnCwd})`);
+              return;
+            }
+            console.error(`[dm-lens-mcp] warm turn-end: ${turnCwd}`);
+            await ensureReady(turnCwd);
+            const delivery = await runTurnEndForIpc(turnCwd);
+            const result = {
+              route: "turn-end",
+              version: WARM_TURN_END_SCHEMA_VERSION,
+              turnEnd: delivery.outcome.turnEnd,
+              tests: delivery.outcome.tests,
+              deliveryId: delivery.deliveryId
+            };
+            socket.end(`${JSON.stringify({ result })}
+`);
+            return;
+          }
+          const req = parsed;
+          console.error(`[dm-lens-mcp] warm analyze: ${req.file}`);
+          const result = await analyzeFile(req.file, req.cwd, {
+            registerTurnState: true,
+            updateGraph: true
+          });
+          socket.end(`${JSON.stringify({ result })}
+`);
+        } catch (err) {
+          socket.end(`${JSON.stringify({ error: String(err) })}
+`);
+        }
+      });
+    }, {
+      label: "mcp-warm-server",
+      onOverflow: () => socket.end(`${JSON.stringify({ error: "warm request line exceeded the framing limit" })}
+`)
+    }));
+    socket.on("error", () => {});
+  });
+  ipc.on("error", (err) => {
+    console.error(`[dm-lens-mcp] IPC listener unavailable: ${err}`);
+  });
+  ipc.listen(IPC_PATH, () => {
+    console.error(`[dm-lens-mcp] warm side-channel listening at ${IPC_PATH}`);
+  });
+  const cleanup = () => {
+    try {
+      ipc.close();
+    } catch {}
+    if (process.platform !== "win32") {
+      try {
+        fs.unlinkSync(IPC_PATH);
+      } catch {}
+    }
+  };
+  process.on("exit", cleanup);
+}
+function send(message) {
+  process.stdout.write(`${JSON.stringify(message)}
+`);
+}
+function sendResult(id, result) {
+  send({ jsonrpc: "2.0", id, result });
+}
+function sendError(id, code, message) {
+  send({ jsonrpc: "2.0", id, error: { code, message } });
+}
+const GRAPH_STALENESS_THRESHOLD_MS = 10 * 60000;
+function formatRelativeAge(ms) {
+  if (ms < 60000)
+    return `${Math.round(ms / 1000)}s ago`;
+  if (ms < 60 * 60000)
+    return `${Math.round(ms / 60000)}m ago`;
+  if (ms < 24 * 60 * 60000)
+    return `${Math.round(ms / (60 * 60000))}h ago`;
+  return `${Math.round(ms / (24 * 60 * 60000))}d ago`;
+}
+function graphStalenessNote(builtAtIso, label) {
+  if (!builtAtIso)
+    return;
+  const builtAtMs = Date.parse(builtAtIso);
+  if (!Number.isFinite(builtAtMs))
+    return;
+  const ageMs = Date.now() - builtAtMs;
+  if (ageMs < GRAPH_STALENESS_THRESHOLD_MS)
+    return;
+  return `${label} last updated ${formatRelativeAge(ageMs)}; run dmlens_analyze ` + "on recently-changed files, dmlens_session_start, or dmlens_rebuild to refresh it.";
+}
+const cacheManager = new CacheManager;
+const isLensGuardEnabled = () => Boolean(createMcpHost(undefined, DEFAULT_CWD).getFlag("lens-guard"));
+const lensDiagnosticsTool = createLensDiagnosticsTool(cacheManager, () => DEFAULT_CWD, undefined, undefined, undefined, undefined, () => peekMcpSessionRuntime(), () => isLensGuardEnabled());
+const astGrepClient = new AstGrepClient;
+const astGrepSearchTool = createAstGrepSearchTool(astGrepClient);
+const astGrepReplaceTool = createAstGrepReplaceTool(astGrepClient);
+const lspNavigationTool = createLspNavigationTool((name, cwd) => createMcpHost(undefined, cwd ?? DEFAULT_CWD).getFlag(name));
+function schemaWithCwd(parameters) {
+  const p = parameters;
+  return {
+    type: "object",
+    properties: {
+      ...p.properties,
+      cwd: {
+        type: "string",
+        description: "Project root (defaults to the server workspace)."
+      }
+    },
+    ...p.required ? { required: p.required } : {}
+  };
+}
+const ALL_TOOLS = [
+  {
+    name: "dmlens_analyze",
+    description: "Run dm-lens's per-edit dispatch pipeline on one file. Example: analyze `src/app.ts` after an edit.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Path to the file to analyze (absolute, or relative to cwd)."
+        },
+        cwd: {
+          type: "string",
+          description: "Project root. Defaults to the server's workspace."
+        },
+        mode: {
+          type: "string",
+          enum: ["warm", "fresh"],
+          description: "warm (default): run in this server process — fast, warm LSP, but reflects the code the server was started with. fresh: fork a worker that loads the freshly-built code from disk — slower, but reflects the latest commit (the honest review loop; pair with dmlens_rebuild)."
+        },
+        flags: {
+          type: "object",
+          description: 'Optional dm-lens flag overrides for this run, e.g. {"no-lsp": true} to bench the non-LSP path.'
+        }
+      },
+      required: ["file"]
+    }
+  },
+  {
+    name: "dmlens_diagnostics",
+    description: lensDiagnosticsTool.description,
+    inputSchema: schemaWithCwd(lensDiagnosticsTool.parameters)
+  },
+  {
+    name: "dmlens_latency",
+    description: "Return recent dispatch latency reports. Example: limit results to 5.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Max reports to return (default 5)."
+        },
+        file: {
+          type: "string",
+          description: "Only reports whose path ends with this."
+        }
+      }
+    }
+  },
+  {
+    name: "dmlens_rebuild",
+    description: "Rebuild dm-lens so later fresh analyses use the latest commit. Example: rebuild after changing a tool.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "dmlens_project_scan",
+    description: "Scan project files for structural and quality diagnostics. Example: cap the scan with `maxFiles: 20`.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cwd: { type: "string" },
+        maxFiles: { type: "number", description: "Cap files scanned." },
+        includeGenerated: {
+          type: "boolean",
+          description: "Scan WITHOUT the generated/artifact NAME-heuristic filter " + "(lockfiles, gen.ts-style names, generated/ dirs, …). Default " + "false. Use when a scan's 'excluded by generated-name " + "heuristics' notice suggests a real file was skipped."
+        }
+      }
+    }
+  },
+  {
+    name: "dmlens_symbol_search",
+    description: "Find relevant files by ranked identifier search. On a cold cache, project_report and symbol_search return available: false with a retry hint and start a non-blocking background build; module_report degrades to outline-only with cache freshness explicit. Example: search `authenticate user` before dmlens_module_report.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Identifier-ish query, e.g. 'authenticate user'. Mix in composable prefix filters: lang:<kind> (e.g. lang:jsts, lang:python — kinds from file-kinds.ts), file:<substr> (path substring), ext:<ext> (e.g. ext:ts or ext:.ts), each optionally negated with a leading '-' (-file:test). Filters apply before ranking; e.g. 'lang:jsts file:clients/ -file:test rank'. Unknown prefixes/kinds error with the supported list."
+        },
+        cwd: { type: "string" },
+        limit: {
+          type: "number",
+          description: "Max files to return (default 20)."
+        },
+        paths: {
+          type: "array",
+          items: { type: "string" },
+          description: "Glob array scoping hits to matching files — same shape/semantics as dmlens_ast_grep_search's `paths` (a bare directory/file entry scopes its whole subtree). Filters before ranking, so scores within the scoped set are unaffected."
+        },
+        lang: {
+          type: "string",
+          description: "Restrict hits to one language, using the same identifiers as dmlens_ast_grep_search's `lang` param (e.g. 'typescript', 'python', 'go')."
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "dmlens_module_report",
+    description: "Return a navigable source-module outline with references and read handles. An outline shows shape, not bodies, and does not satisfy read-before-edit; `read_symbol` and `read_enclosing` return body text and record read coverage. On a cold cache, project_report and symbol_search return available: false with a retry hint and start a non-blocking background build; module_report degrades to outline-only with cache freshness explicit. Example: use dmlens_module_report on `src/app.ts` before dmlens_read_symbol.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "File to report on (absolute or relative to cwd)."
+        },
+        cwd: { type: "string" },
+        maxRefsPerSymbol: {
+          type: "number",
+          description: "Cap who-uses-this entries per symbol (default 10)."
+        },
+        focus: {
+          type: "string",
+          description: "Optional task hint used only to rank recommendedReads (does not expand scope or trigger scans)."
+        },
+        view: {
+          type: "string",
+          enum: ["summary", "default", "compact"],
+          description: "Payload tier. summary returns top-level entries/recommendedReads with heavy callback/usedBy/blast-radius payloads omitted. compact (cheapest) returns a line-oriented TEXT rendering of the full report instead of JSON."
+        },
+        blastRadius: {
+          type: "boolean",
+          description: "Include the cross-file blast radius: transitive dependents aggregated to ranked file reads. Read-only over the cached graph (omitted when cold)."
+        },
+        blastRadiusDepth: {
+          type: "number",
+          description: "Max hops for the blast-radius walk (default 3). Only used with blastRadius."
+        },
+        callGraph: {
+          type: "boolean",
+          description: "Include bounded derived callers/callees from the cached FunctionCallGraph; cold or stale cache state is explicit."
+        },
+        maxCallGraphEntries: {
+          type: "number",
+          description: "Per-direction cap for call-graph relations (default 20)."
+        }
+      },
+      required: ["file"]
+    }
+  },
+  {
+    name: "dmlens_project_report",
+    description: "Orient in a project from its review graph. On a cold cache, project_report and symbol_search return available: false with a retry hint and start a non-blocking background build; module_report degrades to outline-only with cache freshness explicit. Example: use dmlens_project_report before choosing a file.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cwd: { type: "string" },
+        limit: {
+          type: "number",
+          description: "Scales every ranked section's cap (default 10) — a single knob for all sections."
+        },
+        focus: {
+          type: "string",
+          description: "Optional task hint used only to re-rank sections toward relevant subsystems (does not expand scope or trigger scans)."
+        },
+        view: {
+          type: "string",
+          enum: ["default", "compact"],
+          description: "Payload tier. compact (cheapest) returns a line-oriented TEXT rendering instead of JSON. Default returns JSON."
+        }
+      }
+    }
+  },
+  {
+    name: "dmlens_read_symbol",
+    description: "Return one symbol's verbatim source. An outline shows shape, not bodies, and does not satisfy read-before-edit; `read_symbol` and `read_enclosing` return body text and record read coverage. Example: use dmlens_read_symbol after dmlens_module_report identifies `parseConfig`.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: { type: "string", description: "File containing the symbol." },
+        symbol: {
+          type: "string",
+          description: "Exact symbol name to read, or a dotted `Class.method` to disambiguate a member."
+        },
+        kind: {
+          type: "string",
+          description: "Optional kind filter (e.g. function, interface, class) to disambiguate when multiple same-file symbols share the requested name."
+        },
+        cwd: { type: "string" }
+      },
+      required: ["file", "symbol"]
+    }
+  },
+  {
+    name: "dmlens_read_enclosing",
+    description: "Return the smallest symbol or callback enclosing a line. An outline shows shape, not bodies, and does not satisfy read-before-edit; `read_symbol` and `read_enclosing` return body text and record read coverage. Example: use dmlens_read_enclosing after a diagnostic points to line 42.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "Absolute or workspace-relative path to the source file."
+        },
+        line: {
+          type: "number",
+          description: "1-based line number inside the desired symbol/callback."
+        },
+        cwd: { type: "string" },
+        kinds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional kind filter, e.g. function, method, callback, class."
+        },
+        maxLines: {
+          type: "number",
+          description: "Optional maximum body size to return. Oversized matches obey onOversize."
+        },
+        onOversize: {
+          type: "string",
+          enum: ["error", "slice", "outline"],
+          description: "Behavior when the enclosing body exceeds maxLines. error (default) returns metadata only; slice returns a bounded partial read around line; outline returns nested symbols/callbacks with read handles."
+        },
+        aroundLine: {
+          type: "number",
+          description: "Maximum lines for onOversize=slice; defaults to maxLines, then 80."
+        }
+      },
+      required: ["file", "line"]
+    }
+  },
+  {
+    name: "dmlens_health",
+    description: "Return dm-lens runtime health for this server. Example: call it after a slow analysis.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "dmlens_effective_config",
+    description: "Explain resolved configuration and provenance. Response is redacted by construction: it contains no environment values, no command arguments beyond the binary, and home-relative paths; a tier-denied LSP decision cannot be lifted by a nearer config. Example: pass `file` to explain one selection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cwd: { type: "string" },
+        file: {
+          type: "string",
+          description: "Path to explain: adds the resolved language plus the per-server and " + "per-runner selection decisions for it. Must resolve inside `cwd` " + "(a sibling package in the same monorepo does not count) — a file " + "outside it is rejected with the `cwd` it was measured against; " + "re-query with `cwd` set to that file's own workspace instead."
+        }
+      }
+    }
+  },
+  {
+    name: "dmlens_session_start",
+    description: "Initialize dm-lens for a workspace. Example: run once before reviewing a project.",
+    inputSchema: {
+      type: "object",
+      properties: { cwd: { type: "string" } }
+    }
+  },
+  {
+    name: "dmlens_turn_end",
+    description: "Summarize checks for files changed this turn. Example: pass `files` for an unanalysed file.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cwd: { type: "string" },
+        files: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional extra files to include (auto-registered ones are already picked up)."
+        }
+      }
+    }
+  },
+  {
+    name: "dmlens_session_end",
+    description: "End the MCP connection's telemetry session and write its bounded situational-tool telemetry line. This is terminal for the connection.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "dmlens_ast_grep_search",
+    description: "Search code by AST structure rather than text. Example: find calls with `console.log($MSG)`.",
+    inputSchema: schemaWithCwd(astGrepSearchTool.parameters)
+  },
+  {
+    name: "dmlens_ast_grep_replace",
+    description: "Find and rewrite code by AST structure; preview by default. Example: set `apply: false` to inspect a diff.",
+    inputSchema: schemaWithCwd(astGrepReplaceTool.parameters)
+  },
+  {
+    name: "dmlens_lsp_navigation",
+    description: 'Navigate source with language-server operations. Example: use `{operation: "references", path: "src/app.ts", line: 12}`.',
+    inputSchema: schemaWithCwd(lspNavigationTool.parameters)
+  }
+];
+const TOOLS = canRebuildDmLens(REPO_ROOT) ? ALL_TOOLS : ALL_TOOLS.filter((tool) => tool.name !== "dmlens_rebuild");
+function enabledToolsForCwd(cwd) {
+  const global = loadDmLensGlobalConfig();
+  const project = loadDmLensProjectConfig(cwd);
+  return TOOLS.filter((tool) => {
+    const entry = toolRegistryEntryForMcp(tool.name);
+    return entry !== undefined && resolveLensToolEnabled(entry.name, global, project.raw);
+  });
+}
+function formatAnalyze(result, cwd, mode, servedBy) {
+  const lspNote = result.lsp ? ` · lsp ${result.lsp.diagnosticCount} (${result.lsp.status}, ${result.lsp.durationMs}ms)` : "";
+  const summary = `${path.relative(cwd, result.filePath) || result.filePath} [${mode}] — ` + `${result.counts.blockers} blocking, ${result.counts.warnings} warning(s), ` + `${result.counts.advisories} advisory(ies), ` + `${result.counts.diagnostics} total` + (result.latency ? ` · ${result.latency.totalDurationMs}ms` : "") + lspNote + (result.counts.fixed > 0 ? ` · ${result.counts.fixed} auto-fixed` : "") + (servedBy ? `
+
+servedBy: ${servedBy}` : "");
+  return toolText(summary, servedBy ? { ...result, servedBy } : result);
+}
+function healthConfigLine(provenance) {
+  if (!provenance)
+    return "Config: unavailable (resolution failed)";
+  const tiers = Object.entries(provenance.tiers).filter(([, count]) => count > 0).map(([tier, count]) => `${tier} ${count}`).join(" · ");
+  const codes = Object.entries(provenance.codes).map(([code, count]) => `${code}×${count}`).join(", ");
+  const notices = codes.length > 0 ? ` · notices ${codes}` : "";
+  const documents = `${provenance.documents} file(s)`;
+  return `Config: ${documents} · ${tiers} leaf/leaves${notices}`;
+}
+function effectiveServerLine(server) {
+  const mark = server.selected ? "✓" : "✗";
+  const decided = server.decidedBy;
+  if (!decided)
+    return `  ${mark} ${server.id} — ${server.reason}`;
+  const file = decided.file === undefined ? "" : ` ${decided.file}`;
+  const source = `${decided.tier}${file} → ${decided.key}`;
+  return `  ${mark} ${server.id} — ${server.reason} (${source})`;
+}
+function effectiveFileHeading(file) {
+  const language = file.language === undefined ? "" : ` — ${file.language}`;
+  const kind = file.kind === undefined ? "" : ` (kind ${file.kind})`;
+  return `File: ${file.path}${language}${kind}`;
+}
+function effectiveDocumentLine(document) {
+  const legacy = document.legacy ? " (legacy location — scheduled for removal)" : "";
+  return `  ${document.tier}: ${document.file}${legacy}`;
+}
+async function callTool(name, args) {
+  if (name === "dmlens_lsp_diagnostics") {
+    recordDegradationOnce({
+      kind: "lsp-diagnostics-compatibility",
+      subject: "lsp_diagnostics",
+      reason: "retired tool name redirected to dmlens_diagnostics source=lsp"
+    });
+    name = "dmlens_diagnostics";
+    args = {
+      ...args,
+      source: "lsp",
+      scope: "paths"
+    };
+  }
+  if (name === "dmlens_ast_grep_dump") {
+    recordDegradationOnce({
+      kind: "ast-grep-dump-compatibility",
+      subject: "ast_grep_dump",
+      reason: "retired tool name redirected to ast_grep_search dump mode"
+    });
+    return astGrepDumpCompatibilityResult(args, "mcp");
+  }
+  if (name === "dmlens_analyze") {
+    const file = args.file;
+    if (typeof file !== "string" || file.length === 0) {
+      return {
+        ...toolText("dmlens_analyze requires a 'file' string."),
+        isError: true
+      };
+    }
+    const cwd = typeof args.cwd === "string" ? args.cwd : DEFAULT_CWD;
+    const requestedMode = args.mode === "fresh" ? "fresh" : "warm";
+    const flags = args.flags && typeof args.flags === "object" ? args.flags : undefined;
+    const forcedFresh = requestedMode === "warm" && isWarmBuildStale();
+    const mode = requestedMode === "fresh" || forcedFresh ? "fresh" : "warm";
+    if (mode === "fresh") {
+      const outcome = await analyzeFileFresh(WORKER_PATH, file, cwd, { flags });
+      if (outcome.error || !outcome.result) {
+        return {
+          ...toolText(`fresh analyze failed: ${outcome.error ?? "no result"}`),
+          isError: true
+        };
+      }
+      return formatAnalyze(outcome.result, cwd, "fresh", forcedFresh ? STALE_SERVED_BY_FRESH : undefined);
+    }
+    await ensureReady(cwd);
+    const result = await analyzeFile(file, cwd, {
+      flags,
+      registerTurnState: true,
+      updateGraph: true
+    });
+    return formatAnalyze(result, cwd, "warm");
+  }
+  if (name === "dmlens_rebuild") {
+    const outcome = await runRebuild(REPO_ROOT, REBUILD_SCRIPT);
+    if (!outcome.packageManager) {
+      return {
+        ...toolText(outcome.output, {
+          ok: false,
+          script: outcome.script,
+          repoRoot: REPO_ROOT
+        }),
+        isError: true
+      };
+    }
+    const runCmd = `${outcome.packageManager} run ${outcome.script}`;
+    const headline = outcome.ok ? `✓ rebuild succeeded (${runCmd}, ${outcome.durationMs}ms). Fresh analyses now reflect the latest build.` : `✗ rebuild FAILED (${runCmd}, ${outcome.durationMs}ms).`;
+    return {
+      ...toolText(outcome.ok ? headline : `${headline}
+
+${outcome.output}`, {
+        ok: outcome.ok,
+        script: outcome.script,
+        packageManager: outcome.packageManager,
+        durationMs: outcome.durationMs,
+        repoRoot: REPO_ROOT
+      }),
+      isError: !outcome.ok
+    };
+  }
+  if (name === "dmlens_project_scan") {
+    const cwd = typeof args.cwd === "string" ? args.cwd : DEFAULT_CWD;
+    await ensureReady(cwd);
+    const maxFiles = typeof args.maxFiles === "number" && Number.isFinite(args.maxFiles) ? Math.max(1, Math.floor(args.maxFiles)) : undefined;
+    const includeGenerated = args.includeGenerated === true;
+    const snapshot = await projectScan(cwd, maxFiles, includeGenerated);
+    if (snapshot.unsafeRoot) {
+      return toolText(`Refused to scan: the working directory (${cwd}) resolves at or above the home directory, so a project scan would walk every unrelated tree under it. Run dmlens_project_scan from inside a project directory. This is NOT a clean result — nothing was scanned.`, { filesScanned: 0, unsafeRoot: true, cwd }, true);
+    }
+    const { deduped, byRule, byFile } = summarizeScan(snapshot.diagnostics);
+    const topRules = Object.entries(byRule).sort((a, b) => b[1] - a[1]);
+    const topFiles = Object.entries(byFile).sort((a, b) => b[1] - a[1]).slice(0, 15).map(([file, count]) => ({ file: path.relative(cwd, file), count }));
+    const summaryLines = [
+      `Scanned ${snapshot.filesScanned} file(s) [${snapshot.runners.join(", ")}] → ` + `${deduped.length} unique diagnostic(s)` + (snapshot.diagnostics.length !== deduped.length ? ` (${snapshot.diagnostics.length} raw, ${snapshot.diagnostics.length - deduped.length} duplicate)` : ""),
+      ...topRules.slice(0, 12).map(([rule, count]) => `  ${count}× ${rule}`)
+    ];
+    const truncationNotice = scanTruncationNotice(snapshot);
+    if (truncationNotice)
+      summaryLines.push(truncationNotice);
+    const skipNotice = generatedSkipNotice(snapshot, "mcp");
+    if (skipNotice)
+      summaryLines.push(skipNotice);
+    return toolText(summaryLines.join(`
+`), {
+      filesScanned: snapshot.filesScanned,
+      runners: snapshot.runners,
+      uniqueDiagnostics: deduped.length,
+      rawDiagnostics: snapshot.diagnostics.length,
+      byRule,
+      topFiles,
+      sample: deduped.slice(0, 40),
+      ...snapshot.scanTruncated ? { scanTruncated: true } : {},
+      ...snapshot.treeSitterStatus ? { treeSitterStatus: snapshot.treeSitterStatus } : {},
+      ...snapshot.generatedFileSkips ? { generatedFileSkips: snapshot.generatedFileSkips } : {},
+      ...snapshot.generatedNameOnlySkips ? { generatedNameOnlySkips: snapshot.generatedNameOnlySkips } : {},
+      ...snapshot.generatedDirSkips ? { generatedDirSkips: snapshot.generatedDirSkips } : {}
+    });
+  }
+  if (name === "dmlens_symbol_search") {
+    const query = typeof args.query === "string" ? args.query : "";
+    if (!query.trim())
+      return toolText("Provide a non-empty `query`.");
+    const cwd = typeof args.cwd === "string" ? args.cwd : DEFAULT_CWD;
+    const limit = typeof args.limit === "number" && Number.isFinite(args.limit) ? Math.max(1, Math.floor(args.limit)) : 20;
+    const paths = Array.isArray(args.paths) ? args.paths.filter((p) => typeof p === "string") : undefined;
+    const lang = typeof args.lang === "string" ? args.lang : undefined;
+    const { available, results, hint, unavailableReason, coverage, snapshotGeneratedAt } = await symbolSearch(query, cwd, limit, { paths, lang });
+    if (!available) {
+      return toolText(hint ?? "No word index for this workspace yet — run dmlens_session_start first.", { available: false, query, hint, unavailableReason }, true);
+    }
+    const stalenessNote = graphStalenessNote(snapshotGeneratedAt, "Project snapshot");
+    if (results.length === 0) {
+      return toolText(`No files matched "${query}".` + (coverage ? `
+Index covers ${coverage.files} files${coverage.truncated ? " (capped — results may be incomplete)" : ""}.` : "") + (stalenessNote ? `
+
+${stalenessNote}` : ""), {
+        available: true,
+        query,
+        results: [],
+        coverage,
+        ...stalenessNote ? { staleness: stalenessNote } : {}
+      }, true);
+    }
+    const lines = [
+      `Top ${results.length} file(s) for "${query}":`,
+      ...results.map((result, i) => `  ${i + 1}. ${path.relative(cwd, result.file)} ` + `(score ${result.score.toFixed(2)}, ${result.hits} hit(s), ` + `line ${result.startLine})`),
+      ...stalenessNote ? ["", stalenessNote] : [],
+      ...coverage ? [
+        `Index covers ${coverage.files} files${coverage.truncated ? " (capped — results may be incomplete)" : ""}.`
+      ] : []
+    ];
+    return toolText(lines.join(`
+`), {
+      query,
+      coverage,
+      results: results.map((result) => {
+        const relFile = path.relative(cwd, result.file);
+        return {
+          file: relFile,
+          score: result.score,
+          hits: result.hits,
+          startLine: result.startLine,
+          endLine: result.endLine,
+          ...result.annotations ? { annotations: result.annotations } : {},
+          suggestedNext: { tool: "dmlens_module_report", path: relFile }
+        };
+      }),
+      ...stalenessNote ? { staleness: stalenessNote } : {}
+    }, true);
+  }
+  if (name === "dmlens_module_report") {
+    const file = typeof args.file === "string" ? args.file : "";
+    if (!file.trim())
+      return { ...toolText("Provide a `file`."), isError: true };
+    const cwd = typeof args.cwd === "string" ? args.cwd : DEFAULT_CWD;
+    const maxRefsPerSymbol = typeof args.maxRefsPerSymbol === "number" && Number.isFinite(args.maxRefsPerSymbol) ? Math.max(1, Math.floor(args.maxRefsPerSymbol)) : undefined;
+    const blastRadius = args.blastRadius === true;
+    const blastRadiusDepth = typeof args.blastRadiusDepth === "number" && Number.isFinite(args.blastRadiusDepth) ? Math.max(1, Math.floor(args.blastRadiusDepth)) : undefined;
+    const callGraph = args.callGraph === true;
+    const maxCallGraphEntries = typeof args.maxCallGraphEntries === "number" && Number.isFinite(args.maxCallGraphEntries) ? Math.max(1, Math.floor(args.maxCallGraphEntries)) : undefined;
+    const view = args.view === "summary" || args.view === "compact" ? args.view : undefined;
+    const focus = typeof args.focus === "string" ? args.focus : undefined;
+    const report = await moduleReport(file, cwd, {
+      maxRefsPerSymbol,
+      blastRadius,
+      blastRadiusDepth,
+      callGraph,
+      maxCallGraphEntries,
+      view,
+      focus
+    });
+    if (!report.available) {
+      return {
+        ...toolText(`No module report for ${path.relative(cwd, path.resolve(cwd, file))} — not a symbol-bearing file, or unreadable.`, report, true),
+        isError: true
+      };
+    }
+    const graphStaleness = graphStalenessNote(report.graphBuiltAt, "Review graph");
+    const summary = `${path.relative(cwd, report.path) || report.path} [${report.staleness}] — ` + `${report.summary.symbols} symbol(s), ${report.summary.exports} exported, ` + `${report.api.length} in public API` + (graphStaleness ? `
+
+${graphStaleness}` : "");
+    if (view === "compact") {
+      const compactText = renderCompactModuleReport(report);
+      return {
+        content: [
+          {
+            type: "text",
+            text: graphStaleness ? `${compactText}
+
+${graphStaleness}` : compactText
+          }
+        ]
+      };
+    }
+    return toolText(summary, graphStaleness ? { ...report, graphStalenessNote: graphStaleness } : report, true);
+  }
+  if (name === "dmlens_project_report") {
+    const cwd = typeof args.cwd === "string" ? args.cwd : DEFAULT_CWD;
+    const limit = typeof args.limit === "number" && Number.isFinite(args.limit) ? Math.max(1, Math.floor(args.limit)) : undefined;
+    const focus = typeof args.focus === "string" ? args.focus : undefined;
+    const view = args.view === "compact" ? "compact" : undefined;
+    const report = await projectReport(cwd, { limit, focus, view });
+    if (!report.available) {
+      return {
+        ...toolText(report.hint ?? "No review graph cached for this workspace yet.", report),
+        isError: true
+      };
+    }
+    const graphStaleness = report.trust ? graphStalenessNote(report.trust.graphBuiltAt, "Review graph") : undefined;
+    if (view === "compact") {
+      const compactText = renderCompactProjectReport(report);
+      return {
+        content: [
+          {
+            type: "text",
+            text: graphStaleness ? `${compactText}
+
+${graphStaleness}` : compactText
+          }
+        ]
+      };
+    }
+    const summary = `Project report — ${report.hubs?.length ?? 0} hub(s), ` + `${report.entryPoints?.length ?? 0} entry point(s), ` + `${report.riskHotspots?.length ?? 0} risk hotspot(s)` + (graphStaleness ? `
+
+${graphStaleness}` : "");
+    return toolText(summary, graphStaleness ? { ...report, graphStalenessNote: graphStaleness } : report, true);
+  }
+  if (name === "dmlens_read_symbol") {
+    const file = typeof args.file === "string" ? args.file : "";
+    const symbol = typeof args.symbol === "string" ? args.symbol : "";
+    if (!file.trim() || !symbol.trim()) {
+      return { ...toolText("Provide `file` and `symbol`."), isError: true };
+    }
+    const cwd = typeof args.cwd === "string" ? args.cwd : DEFAULT_CWD;
+    const kind = typeof args.kind === "string" ? args.kind : undefined;
+    const result = await readSymbol(file, symbol, cwd, { kind });
+    if (!result.found) {
+      const suggestionSuffix = result.suggestions?.length ? ` Did you mean: ${result.suggestions.join(", ")}?` : " Use dmlens_module_report to list symbols.";
+      return {
+        ...toolText(`Symbol "${symbol}" not found in ${path.basename(file)}.${suggestionSuffix}`, {
+          found: false,
+          ...result.suggestions ? { suggestions: result.suggestions } : {}
+        }),
+        isError: true
+      };
+    }
+    const sigSuffix = result.signature ? `  ${result.signature}` : "";
+    const ambiguityNote = result.ambiguous ? ` (${result.ambiguous.count} matches — returned the ${result.kind}; pass \`kind\` to disambiguate: ${result.ambiguous.kinds.join(", ")})` : "";
+    const header = `${result.kind} ${result.name}${ambiguityNote}${sigSuffix}  ${path.relative(cwd, result.path)}:${result.startLine}-${result.endLine}`;
+    return {
+      content: [
+        {
+          type: "text",
+          text: `${header}
+
+${result.source ?? ""}`
+        }
+      ]
+    };
+  }
+  if (name === "dmlens_read_enclosing") {
+    const file = typeof args.file === "string" ? args.file : "";
+    const line = typeof args.line === "number" ? args.line : Number.NaN;
+    if (!file.trim() || !Number.isFinite(line)) {
+      return {
+        ...toolText("Provide `file` and a numeric `line`."),
+        isError: true
+      };
+    }
+    const cwd = typeof args.cwd === "string" ? args.cwd : DEFAULT_CWD;
+    const kinds = Array.isArray(args.kinds) ? args.kinds.filter((k) => typeof k === "string") : undefined;
+    const maxLines = typeof args.maxLines === "number" && Number.isFinite(args.maxLines) ? Math.max(1, Math.floor(args.maxLines)) : undefined;
+    const onOversize = args.onOversize === "error" || args.onOversize === "slice" || args.onOversize === "outline" ? args.onOversize : undefined;
+    const aroundLine = typeof args.aroundLine === "number" && Number.isFinite(args.aroundLine) ? Math.max(1, Math.floor(args.aroundLine)) : undefined;
+    const result = await readEnclosing(file, line, cwd, {
+      kinds,
+      maxLines,
+      onOversize,
+      aroundLine
+    });
+    if (!result.found) {
+      const warningSuffix = result.warnings?.length ? ` Warnings: ${result.warnings.join("; ")}` : "";
+      const outlineSuffix = result.outline?.length ? `
+
+Nested outline:
+${JSON.stringify(result.outline)}` : "";
+      const text = result.error ? `Could not read enclosing range in ${path.basename(file)}:${result.line}: ${result.error}${warningSuffix}${outlineSuffix}` : `No enclosing symbol/callback found in ${path.basename(file)}:${result.line}.${warningSuffix}`;
+      return {
+        ...toolText(text, { found: false, line: result.line }),
+        isError: true
+      };
+    }
+    const range = result.partial ? `${result.startLine}-${result.endLine} (partial of ${result.enclosingStartLine}-${result.enclosingEndLine})` : `${result.startLine}-${result.endLine}`;
+    const header = `${result.kind} ${result.name}  ${path.relative(cwd, result.path)}:${range}`;
+    return {
+      content: [
+        {
+          type: "text",
+          text: `${header}
+
+${result.source ?? ""}`
+        }
+      ]
+    };
+  }
+  if (name === "dmlens_health") {
+    const { aliveClients, servers, brokenServers } = lspStatus();
+    const last = recentLatency(1)[0];
+    const stats = diagnosticStats();
+    const autoSession = getAutoSessionStatus();
+    const treeSitter = treeSitterRuntimeStatus();
+    const degradations = getDegradationSummary();
+    const turnEnd = readTurnEndStatus(DEFAULT_CWD) ?? null;
+    const configProvenance = await effectiveConfig({ cwd: DEFAULT_CWD }).then((view) => ({
+      documents: view.documents.length,
+      tiers: view.provenanceCounts,
+      codes: view.recordCounts
+    })).catch(() => null);
+    const footprint = await resourceFootprint().catch(() => null);
+    const lines = [
+      treeSitter.wasmAborted ? `Tree-sitter: DEGRADED — WASM runtime aborted${treeSitter.abortedAt ? ` at ${treeSitter.abortedAt}` : ""}; restart this server to recover` : "Tree-sitter: available",
+      `LSP: ${aliveClients} alive client(s)`,
+      ...servers.flatMap((server) => [
+        `  ${server.connected ? "✓" : "✗"} ${server.serverId} (${server.root})`,
+        ...server.pullFailureHistory.slice(-1).map((failure) => `    ⚠ diagnostics pull failed: ${failure.method}${failure.code !== undefined ? ` (${failure.code})` : ""} — ${failure.message.length > 200 ? `${failure.message.slice(0, 200)}…` : failure.message}`)
+      ]),
+      ...renderLspBrokenStatusLines(brokenServers),
+      ...renderDegradationLines(degradations),
+      last ? `Last dispatch: ${path.basename(last.filePath)} — ${last.totalDurationMs}ms, ${last.totalDiagnostics} diagnostic(s)` : "Last dispatch: none yet",
+      `Diagnostics this session: ${stats.totalShown} shown · ${stats.totalAutoFixed} auto-fixed · ${stats.totalUnresolved} unresolved`,
+      autoSession ? `Auto session_start: ${autoSession.succeeded ? "succeeded" : autoSession.error ? "FAILED" : autoSession.attempted ? "in progress" : "not yet attempted"}${autoSession.firedAt ? ` (fired ${autoSession.firedAt})` : ""}${autoSession.error ? ` — ${autoSession.error}` : ""}` : "Auto session_start: disabled (DM_LENS_MCP_AUTO_SESSION not set)",
+      turnEnd ? `Stop-hook turn-end: ${turnEnd.ran} ran · ${turnEnd.skipped} skipped` + `${turnEnd.lastRunAt ? ` (last ran ${turnEnd.lastRunAt})` : ""}` + `${turnEnd.lastSkipReason ? ` — last skip: ${turnEnd.lastSkipReason}${turnEnd.lastSkipAt ? ` at ${turnEnd.lastSkipAt}` : ""}` : ""}` : "Stop-hook turn-end: no activity recorded (hook not installed, or no Stop yet)",
+      healthConfigLine(configProvenance),
+      footprint ? `Resource footprint: ${footprint.instanceCount} dm-lens instance(s) · ` + `${(footprint.totalRssBytes / 1024 / 1024).toFixed(0)}MB RSS · ` + `${footprint.totalCpuPercent.toFixed(1)}% CPU · ` + `${footprint.totalLspChildCount} LSP child process(es)` : "Resource footprint: unavailable (instance registry unreadable)"
+    ];
+    return toolText(lines.join(`
+`), {
+      aliveClients,
+      servers,
+      brokenServers,
+      lastDispatch: last ? {
+        filePath: last.filePath,
+        totalDurationMs: last.totalDurationMs,
+        totalDiagnostics: last.totalDiagnostics
+      } : undefined,
+      diagnostics: {
+        shown: stats.totalShown,
+        autoFixed: stats.totalAutoFixed,
+        unresolved: stats.totalUnresolved
+      },
+      autoSession,
+      treeSitter,
+      turnEnd,
+      resourceFootprint: footprint,
+      degradations,
+      configProvenance
+    });
+  }
+  if (name === "dmlens_effective_config") {
+    const cwd = typeof args.cwd === "string" ? args.cwd : DEFAULT_CWD;
+    const view = await effectiveConfig({
+      cwd,
+      ...typeof args.file === "string" ? { file: args.file } : {},
+      redact: true
+    });
+    const fileLines = view.file === undefined ? [] : isEffectiveFileViewError(view.file) ? [`File: ${view.file.error}`] : [
+      effectiveFileHeading(view.file),
+      ...view.file.servers.filter((server) => server.reason !== "extension-mismatch").map(effectiveServerLine),
+      ...view.file.tools.map((tool) => `  ${tool.selected ? "✓" : "✗"} ${tool.id} — ${tool.reason}`)
+    ];
+    const lines = [
+      `Config: ${view.documents.length} file(s) contributing, ${view.provenance.length} resolved leaf/leaves`,
+      ...view.documents.map(effectiveDocumentLine),
+      ...fileLines
+    ];
+    return toolText(lines.join(`
+`), view);
+  }
+  if (name === "dmlens_diagnostics") {
+    const cwd = typeof args.cwd === "string" ? args.cwd : DEFAULT_CWD;
+    await ensureReady(cwd);
+    const out = await lensDiagnosticsTool.execute("mcp", args, new AbortController().signal, undefined, { cwd, host: "mcp" });
+    return out;
+  }
+  if (name === "dmlens_latency") {
+    const limit = typeof args.limit === "number" && Number.isFinite(args.limit) ? Math.max(1, Math.floor(args.limit)) : 5;
+    const fileFilter = typeof args.file === "string" ? args.file : undefined;
+    const recent = recentLatency(limit, fileFilter);
+    const summary = recent.length === 0 ? "No dispatch latency reports yet." : recent.map((report) => `${path.basename(report.filePath)}: ${report.totalDurationMs}ms ` + `(${report.totalDiagnostics} diag${report.stoppedEarly ? ", stopped early" : ""})`).join(`
+`);
+    return toolText(summary, recent);
+  }
+  if (name === "dmlens_session_start") {
+    const cwd = typeof args.cwd === "string" ? args.cwd : DEFAULT_CWD;
+    await ensureReady(cwd);
+    const outcome = await runSessionStart(cwd);
+    const lines = [
+      `Session started for ${cwd}.`,
+      `LSP: ${outcome.aliveLspClients} alive client(s) (warming continues in background).`,
+      outcome.errorDebtBaseline ? `Error-debt baseline: tests ${outcome.errorDebtBaseline.testsPassed ? "pass" : "FAIL"}, build ${outcome.errorDebtBaseline.buildPassed ? "pass" : "FAIL"}.` : "Error-debt baseline: computing in background.",
+      "knip/jscpd/type-coverage/dep scans run in background — query dmlens_diagnostics shortly.",
+      outcome.guidance ? `
+${outcome.guidance}` : ""
+    ];
+    return toolText(lines.filter(Boolean).join(`
+`), outcome);
+  }
+  if (name === "dmlens_session_end") {
+    endSituationalToolTelemetry();
+    return toolText("Session ended.");
+  }
+  if (name === "dmlens_turn_end") {
+    const cwd = typeof args.cwd === "string" ? args.cwd : DEFAULT_CWD;
+    await ensureReady(cwd);
+    const files = Array.isArray(args.files) ? args.files.filter((file) => typeof file === "string") : [];
+    const outcome = await runTurnEnd(cwd, files);
+    const parts = [
+      `Turn-end over ${outcome.filesRegistered} file(s).`,
+      outcome.turnEnd ?? "No turn-end advisory.",
+      outcome.tests ? `
+Tests:
+${outcome.tests}` : ""
+    ];
+    return toolText(parts.filter(Boolean).join(`
+`), outcome);
+  }
+  if (name === "dmlens_ast_grep_search" || name === "dmlens_ast_grep_replace") {
+    const cwd = typeof args.cwd === "string" ? args.cwd : DEFAULT_CWD;
+    const tool = name === "dmlens_ast_grep_search" ? astGrepSearchTool : astGrepReplaceTool;
+    const out = await tool.execute("mcp", args, new AbortController().signal, undefined, { cwd, resultMaxItems: Number.POSITIVE_INFINITY });
+    return out;
+  }
+  if (name === "dmlens_lsp_navigation") {
+    const cwd = typeof args.cwd === "string" ? args.cwd : DEFAULT_CWD;
+    await ensureReady(cwd);
+    const tool = lspNavigationTool;
+    const out = await tool.execute("mcp", args, new AbortController().signal, undefined, { cwd });
+    return out;
+  }
+  return { ...toolText(`Unknown tool: ${name}`), isError: true };
+}
+const WARN_ONLY_STALE_TOOLS = new Set([
+  "dmlens_module_report",
+  "dmlens_project_report",
+  "dmlens_symbol_search",
+  "dmlens_project_scan",
+  "dmlens_health",
+  "dmlens_latency",
+  "dmlens_session_start",
+  "dmlens_turn_end",
+  "dmlens_ast_grep_search",
+  "dmlens_ast_grep_replace",
+  "dmlens_lsp_navigation",
+  "dmlens_read_symbol",
+  "dmlens_read_enclosing",
+  "dmlens_effective_config"
+]);
+function withStaleWarning(result) {
+  if (result.content.length === 0)
+    return result;
+  const last = result.content[result.content.length - 1];
+  return {
+    ...result,
+    content: [
+      ...result.content.slice(0, -1),
+      {
+        ...last,
+        text: `${last.text}
+
+warmCodeStale: true
+${STALE_WARN_ONLY}`
+      }
+    ]
+  };
+}
+async function handleRequest(request) {
+  const { id, method, params } = request;
+  const isNotification = id === undefined;
+  switch (method) {
+    case "initialize": {
+      startSituationalToolTelemetrySession("mcp");
+      const requested = params?.protocolVersion;
+      sendResult(id ?? null, {
+        protocolVersion: typeof requested === "string" ? requested : FALLBACK_PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }
+      });
+      maybeAutoSessionStart();
+      return;
+    }
+    case "notifications/initialized":
+    case "initialized":
+      return;
+    case "ping":
+      if (!isNotification)
+        sendResult(id ?? null, {});
+      return;
+    case "tools/list":
+      sendResult(id ?? null, { tools: enabledToolsForCwd(DEFAULT_CWD) });
+      return;
+    case "tools/call": {
+      const name = params?.name;
+      const args = params?.arguments && typeof params.arguments === "object" ? params.arguments : {};
+      if (typeof name !== "string") {
+        sendError(id ?? null, -32602, "tools/call requires a string 'name'");
+        return;
+      }
+      const enabledName = name === "dmlens_lsp_diagnostics" ? "dmlens_diagnostics" : name;
+      if (name !== "dmlens_ast_grep_dump" && name !== "dmlens_rebuild" && !enabledToolsForCwd(typeof args.cwd === "string" ? args.cwd : DEFAULT_CWD).some((tool) => tool.name === enabledName)) {
+        sendResult(id ?? null, stripResultDetails(finalizeToolResult({
+          ...toolText(`Unknown or disabled tool: ${name}`),
+          isError: true
+        })));
+        return;
+      }
+      const entry = toolRegistryEntryForMcp(name);
+      if (entry && "situational" in entry && entry.situational) {
+        startSituationalToolTelemetrySession("mcp");
+        observeSituationalToolCall(entry.name);
+      }
+      maybeAutoSessionStart();
+      try {
+        let result = await callTool(name, args);
+        if (WARN_ONLY_STALE_TOOLS.has(name) && !result.isError && isWarmBuildStale()) {
+          result = withStaleWarning(result);
+        }
+        const delivery = finalizeToolResultWithDelivery(result);
+        sendResult(id ?? null, stripResultDetails(delivery.result));
+      } catch (err) {
+        sendResult(id ?? null, stripResultDetails(finalizeToolResult({
+          ...toolText(`dm-lens tool '${name}' failed: ${err.message}`),
+          isError: true
+        })));
+      }
+      return;
+    }
+    default:
+      if (!isNotification)
+        sendError(id ?? null, -32601, `Method not found: ${method}`);
+      return;
+  }
+}
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", createWarmIpcLineReader((raw) => {
+  const line = raw.trim();
+  if (line.length === 0)
+    return;
+  let request;
+  try {
+    request = JSON.parse(line);
+  } catch {
+    sendError(null, -32700, "Parse error");
+  }
+  if (request)
+    handleRequest(request);
+}, {
+  label: "mcp-stdio",
+  continuous: true,
+  onOverflow: () => sendError(null, -32700, "Parse error: request line exceeded the framing limit")
+}));
+process.stdin.on("end", () => {
+  endSituationalToolTelemetry();
+  flushExtensionLog().finally(() => process.exit(0));
+});
+startIpcServer();
+console.error(`[dm-lens-mcp] ready (cwd=${DEFAULT_CWD})`);