@ctxo/cli 0.13.0 → 0.14.0

package/dist/index.js

@@ -1,114 +1,13 @@
 #!/usr/bin/env node
 import {
-  ArchitecturalOverlay,
-  BlastRadiusCalculator,
-  BoundaryViolationDetector,
-  CoChangeReader,
-  ContextsViewReader,
-  DeadCodeDetector,
-  DriftDetector,
-  PageRankCalculator,
-  RevertDetector,
-  SessionRecorderAdapter,
-  SimpleGitAdapter,
-  SqliteStorageAdapter,
-  SymbolGraph,
-  SymbolTokenizer,
-  compareCodepoint,
-  detectWorkspace,
-  findCoChangedFilesForBlastRadius,
-  loadConfig,
-  makeGlobMatcher,
-  maskingClusterLabelPatterns,
-  statsEnabled
-} from "./chunk-BYX3UFBJ.js";
-import "./chunk-RFEXMBTG.js";
-import {
-  DetailLevelSchema,
-  EdgeKindSchema,
-  JsonIndexReader,
-  SYMBOL_KINDS,
-  SymbolKindSchema
-} from "./chunk-DT3ZH4AU.js";
+  FAST_ROUTE_COMMANDS,
+  runFastRoute
+} from "./chunk-SRQZDGFZ.js";
+import "./chunk-72CEQEQD.js";
 import {
   createLogger
 } from "./chunk-5DSKZJNN.js";
 
-// src/index.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-// src/adapters/transport/http-server-transport.ts
-import { createServer } from "http";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { randomUUID } from "crypto";
-var log = createLogger("ctxo:http");
-async function startHttpTransport(serverFactory, port) {
-  const sessions = /* @__PURE__ */ new Map();
-  const httpServer = createServer(async (req, res) => {
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Accept, Mcp-Session-Id");
-    res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id");
-    if (req.method === "OPTIONS") {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
-    const sessionId = req.headers["mcp-session-id"];
-    if (sessionId && sessions.has(sessionId)) {
-      try {
-        await sessions.get(sessionId).transport.handleRequest(req, res);
-      } catch (err) {
-        log.error("Request error: %s", err.message);
-        if (!res.headersSent) {
-          res.writeHead(500);
-          res.end();
-        }
-      }
-      return;
-    }
-    if (sessionId && !sessions.has(sessionId)) {
-      res.writeHead(404, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32001, message: "Session not found" }, id: null }));
-      return;
-    }
-    try {
-      const server = await serverFactory();
-      const transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: () => randomUUID()
-      });
-      transport.onclose = () => {
-        if (transport.sessionId) {
-          sessions.delete(transport.sessionId);
-          log.info("Session closed: %s", transport.sessionId);
-        }
-      };
-      await server.connect(transport);
-      await transport.handleRequest(req, res);
-      if (transport.sessionId) {
-        sessions.set(transport.sessionId, { transport, server });
-        log.info("New session: %s (total: %d)", transport.sessionId, sessions.size);
-      }
-    } catch (err) {
-      log.error("Session creation error: %s", err.message);
-      if (!res.headersSent) {
-        res.writeHead(500);
-        res.end();
-      }
-    }
-  });
-  return new Promise((resolve, reject) => {
-    httpServer.on("error", reject);
-    httpServer.listen(port, () => {
-      log.info("MCP HTTP server listening on http://localhost:%d", port);
-      process.stderr.write(`[ctxo] MCP HTTP server running at http://localhost:${port}
-`);
-      resolve({ httpServer });
-    });
-  });
-}
-
 // src/cli/http-port.ts
 var DEFAULT_HTTP_PORT = "3001";
 function resolveHttpPort(args, env) {
@@ -120,2785 +19,25 @@ function resolveHttpPort(args, env) {
 }
 
 // src/index.ts
-import { z as z15 } from "zod";
-import { existsSync, readFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-
-// src/core/masking/masking-pipeline.ts
-var DEFAULT_PATTERNS = [
-  // AWS Access Key IDs (AKIA...)
-  { regex: /AKIA[0-9A-Z]{16}/g, label: "AWS_KEY" },
-  // AWS Secret Access Keys (40 char base64 containing / or +). The `[A-Za-z0-9=]*[/+]`
-  // lookahead is scoped to the token itself (not `.*`, which would reach a later `/` in
-  // the surrounding text, e.g. a file path in JSON, and wrongly redact hex-only git SHAs).
-  { regex: /(?<![A-Za-z0-9/+])(?=[A-Za-z0-9/+=]{40}(?![A-Za-z0-9/+=]))(?=[A-Za-z0-9=]*[/+])[A-Za-z0-9/+=]{40}/g, label: "AWS_SECRET" },
-  // JWT tokens (eyJ...)
-  { regex: /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g, label: "JWT" },
-  // Private IPv4 (10.x.x.x, 172.16-31.x.x, 192.168.x.x)
-  { regex: /\b(?:10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(?:1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3})\b/g, label: "PRIVATE_IP" },
-  // Private IPv6 (fc00::/7)
-  { regex: /\b[fF][cCdD][0-9a-fA-F]{0,2}(?::[0-9a-fA-F]{1,4}){1,7}\b/g, label: "PRIVATE_IPV6" },
-  // Environment variable assignments for secrets
-  { regex: /(?:_SECRET|_KEY|_TOKEN|_PASSWORD)\s*=\s*['"]?[^\s'"]{8,}['"]?/g, label: "ENV_SECRET" },
-  // GCP service account keys
-  { regex: /"private_key"\s*:\s*"-----BEGIN[^"]+"/g, label: "GCP_KEY" },
-  // Azure connection strings
-  { regex: /AccountKey=[A-Za-z0-9+/=]{20,}/g, label: "AZURE_KEY" }
-];
-var MaskingPipeline = class _MaskingPipeline {
-  patterns;
-  constructor(additionalPatterns = []) {
-    this.patterns = [...DEFAULT_PATTERNS, ...additionalPatterns].map(({ regex, label }) => ({
-      regex: new RegExp(regex.source, regex.flags),
-      label
-    }));
-  }
-  static fromConfig(configPatterns) {
-    const additional = [];
-    for (const { pattern, flags, label } of configPatterns) {
-      try {
-        additional.push({ regex: new RegExp(pattern, flags ?? "g"), label });
-      } catch (err) {
-        console.error(`[ctxo:masking] Invalid regex pattern "${pattern}": ${err.message}`);
-      }
-    }
-    return new _MaskingPipeline(additional);
-  }
-  mask(text) {
-    if (text.length === 0) return text;
-    let result = text;
-    for (const { regex, label } of this.patterns) {
-      result = result.replace(regex, `[REDACTED:${label}]`);
-    }
-    return result;
-  }
-};
-
-// src/adapters/mcp/get-logic-slice.ts
-import { z } from "zod";
-
-// src/core/logic-slice/logic-slice-query.ts
-var LogicSliceQuery = class {
-  getLogicSlice(graph, symbolId, maxDepth = Infinity) {
-    const root = graph.getNode(symbolId);
-    if (!root) return void 0;
-    const visited = /* @__PURE__ */ new Set([root.symbolId]);
-    const dependencies = [];
-    const collectedEdges = [];
-    const queue = [{ id: root.symbolId, depth: 0 }];
-    while (queue.length > 0) {
-      const current = queue.shift();
-      if (current.depth >= maxDepth) continue;
-      const edges = graph.getForwardEdges(current.id);
-      for (const edge of edges) {
-        const depNode = graph.getNode(edge.to);
-        if (!depNode) continue;
-        collectedEdges.push(edge);
-        if (visited.has(edge.to)) continue;
-        visited.add(edge.to);
-        dependencies.push(depNode);
-        queue.push({ id: edge.to, depth: current.depth + 1 });
-      }
-    }
-    return { root, dependencies, edges: collectedEdges };
-  }
-};
-
-// src/core/detail-levels/detail-formatter.ts
-var L1_MAX_LINES = 150;
-var L4_TOKEN_BUDGET = 8e3;
-function withoutAnnotations(node) {
-  if (node.annotations === void 0) return node;
-  const { annotations: _annotations, ...rest } = node;
-  return rest;
-}
-var DetailFormatter = class {
-  format(slice, level) {
-    switch (level) {
-      case 1:
-        return this.formatL1(slice);
-      case 2:
-        return this.formatL2(slice);
-      case 3:
-        return this.formatL3(slice);
-      case 4:
-        return this.formatL4(slice);
-    }
-  }
-  formatL1(slice) {
-    const root = slice.root;
-    const lineCount = root.endLine - root.startLine + 1;
-    const clampedRoot = lineCount > L1_MAX_LINES ? { ...root, endLine: root.startLine + L1_MAX_LINES - 1 } : root;
-    return {
-      root: withoutAnnotations(clampedRoot),
-      dependencies: [],
-      edges: [],
-      level: 1,
-      levelDescription: "L1: Root symbol signature only (no dependencies)",
-      ...lineCount > L1_MAX_LINES ? { truncation: { truncated: true, reason: "token_budget_exceeded" } } : {}
-    };
-  }
-  formatL2(slice) {
-    const directEdges = slice.edges.filter((e) => e.from === slice.root.symbolId);
-    const directDepIds = new Set(directEdges.map((e) => e.to));
-    const directDeps = slice.dependencies.filter((d) => directDepIds.has(d.symbolId));
-    return {
-      root: withoutAnnotations(slice.root),
-      dependencies: directDeps.map(withoutAnnotations),
-      edges: directEdges,
-      level: 2,
-      levelDescription: "L2: Root + direct dependencies (depth 1)"
-    };
-  }
-  formatL3(slice) {
-    return {
-      root: withoutAnnotations(slice.root),
-      dependencies: slice.dependencies.map(withoutAnnotations),
-      edges: slice.edges,
-      level: 3,
-      levelDescription: "L3: Full transitive dependency closure"
-    };
-  }
-  formatL4(slice) {
-    const estimatedTokens = this.estimateTokens(slice);
-    if (estimatedTokens > L4_TOKEN_BUDGET) {
-      const truncated = this.truncateToTokenBudget(slice, L4_TOKEN_BUDGET);
-      return {
-        ...truncated,
-        level: 4,
-        levelDescription: "L4: Full closure with 8K token budget (truncated)",
-        truncation: {
-          truncated: true,
-          reason: "token_budget_exceeded"
-        }
-      };
-    }
-    return {
-      root: slice.root,
-      dependencies: slice.dependencies,
-      edges: slice.edges,
-      level: 4,
-      levelDescription: "L4: Full closure with 8K token budget"
-    };
-  }
-  estimateTokens(slice) {
-    let chars = this.symbolCharEstimate(slice.root);
-    for (const dep of slice.dependencies) {
-      chars += this.symbolCharEstimate(dep);
-    }
-    for (const edge of slice.edges) {
-      chars += edge.from.length + edge.to.length + edge.kind.length + 10;
-    }
-    return Math.ceil(chars / 4);
-  }
-  symbolCharEstimate(node) {
-    if (node.startOffset !== void 0 && node.endOffset !== void 0) {
-      return node.endOffset - node.startOffset;
-    }
-    return (node.endLine - node.startLine + 1) * 40;
-  }
-  truncateToTokenBudget(slice, budget) {
-    let currentTokens = this.symbolCharEstimate(slice.root) / 4;
-    const deps = [];
-    const includedIds = /* @__PURE__ */ new Set([slice.root.symbolId]);
-    for (const dep of slice.dependencies) {
-      const depTokens = this.symbolCharEstimate(dep) / 4;
-      if (currentTokens + depTokens > budget) break;
-      currentTokens += depTokens;
-      deps.push(dep);
-      includedIds.add(dep.symbolId);
-    }
-    const edges = slice.edges.filter(
-      (e) => includedIds.has(e.from) && includedIds.has(e.to)
-    );
-    return { root: slice.root, dependencies: deps, edges };
-  }
-};
-
-// src/core/response-envelope.ts
-var DEFAULT_THRESHOLD = 8192;
-var workspaceMeta;
-function setWorkspaceMeta(workspace) {
-  workspaceMeta = workspace;
-}
-var TRUNCATABLE_FIELDS = {
-  impactedSymbols: "Use search_symbols to find specific impacted symbols, or get_blast_radius with a confidence filter.",
-  importers: "Use find_importers with edgeKinds filter or maxDepth to narrow results.",
-  deadSymbols: "Use search_symbols with kind filter to find specific dead symbols.",
-  unusedExports: "Use find_importers to check specific symbols.",
-  results: "Use search_symbols or get_ranked_context with a narrower query.",
-  rankings: "Use get_symbol_importance with kind or filePattern filter to narrow results.",
-  context: "Use get_context_for_task with a smaller tokenBudget.",
-  hierarchies: "Use get_class_hierarchy with a specific symbolId.",
-  scaffolding: "Review the scaffolding markers directly in the listed files.",
-  deadFiles: "Use find_dead_code with includeTests to adjust scope.",
-  files: "Use get_changed_symbols with a narrower since ref or smaller maxFiles.",
-  clusters: "Use get_architectural_overlay with mode=communities and layer filter for a focused view.",
-  candidates: "Use get_architectural_overlay with mode=contexts and candidate: <id> for one candidate in full, or ctxo contexts --json for the full contexts view.",
-  clustersAffected: "Use get_blast_radius on individual changed symbols for per-cluster impact."
-};
-function getThreshold() {
-  const env = process.env["CTXO_RESPONSE_LIMIT"];
-  if (env) {
-    const n = parseInt(env, 10);
-    if (!isNaN(n) && n > 0) return n;
-  }
-  return DEFAULT_THRESHOLD;
-}
-function findTruncatableArray(data) {
-  let best = null;
-  for (const [key, value] of Object.entries(data)) {
-    if (Array.isArray(value) && key in TRUNCATABLE_FIELDS) {
-      if (!best || value.length > best.arr.length) {
-        best = { key, arr: value };
-      }
-    }
-  }
-  return best;
-}
-function buildMeta(base, extras) {
-  const meta = workspaceMeta ? { ...base, workspace: workspaceMeta } : base;
-  if (extras?.snapshotStaleness) {
-    return { ...meta, snapshotStaleness: extras.snapshotStaleness };
-  }
-  return meta;
-}
-function wrapResponse(data, extras) {
-  const threshold = getThreshold();
-  const fullJson = JSON.stringify(data);
-  const totalBytes = Buffer.byteLength(fullJson, "utf-8");
-  const truncatable = findTruncatableArray(data);
-  const totalItems = truncatable ? truncatable.arr.length : 0;
-  if (totalBytes <= threshold) {
-    return {
-      ...data,
-      _meta: buildMeta(
-        {
-          totalItems,
-          returnedItems: totalItems,
-          truncated: false,
-          totalBytes
-        },
-        extras
-      )
-    };
-  }
-  if (!truncatable || truncatable.arr.length <= 1) {
-    return {
-      ...data,
-      _meta: buildMeta(
-        {
-          totalItems,
-          returnedItems: totalItems,
-          truncated: false,
-          totalBytes
-        },
-        extras
-      )
-    };
-  }
-  let lo = 1;
-  let hi = truncatable.arr.length;
-  while (lo < hi) {
-    const mid = Math.ceil((lo + hi) / 2);
-    const trial = {
-      ...data,
-      [truncatable.key]: truncatable.arr.slice(0, mid),
-      _meta: buildMeta(
-        {
-          totalItems,
-          returnedItems: mid,
-          truncated: true,
-          totalBytes,
-          hint: TRUNCATABLE_FIELDS[truncatable.key]
-        },
-        extras
-      )
-    };
-    const size = Buffer.byteLength(JSON.stringify(trial), "utf-8");
-    if (size <= threshold) {
-      lo = mid;
-    } else {
-      hi = mid - 1;
-    }
-  }
-  const hint = TRUNCATABLE_FIELDS[truncatable.key];
-  return {
-    ...data,
-    [truncatable.key]: truncatable.arr.slice(0, lo),
-    _meta: buildMeta(
-      {
-        totalItems,
-        returnedItems: lo,
-        truncated: true,
-        totalBytes,
-        hint
-      },
-      extras
-    )
-  };
-}
-
-// src/core/intent-filter.ts
-function extractKeywords(intent) {
-  return intent.toLowerCase().split(/\s+/).filter((w) => w.length >= 2);
-}
-function matchesAny(keywords, values) {
-  const lower = values.map((v) => v.toLowerCase());
-  return keywords.some((kw) => lower.some((v) => v.includes(kw)));
-}
-function collectMatchableStrings(entry) {
-  const strings = [];
-  for (const key of ["symbolId", "file", "name", "kind", "edgeKind", "reason", "confidence"]) {
-    const v = entry[key];
-    if (typeof v === "string") strings.push(v);
-  }
-  const edgeKinds = entry["edgeKinds"];
-  if (Array.isArray(edgeKinds)) {
-    for (const ek of edgeKinds) {
-      if (typeof ek === "string") strings.push(ek);
-    }
-  }
-  return strings;
-}
-function filterByIntent(items, intent) {
-  if (!intent || intent.trim().length === 0) return items;
-  const keywords = extractKeywords(intent);
-  if (keywords.length === 0) return items;
-  return items.filter((item) => {
-    const strings = collectMatchableStrings(item);
-    return matchesAny(keywords, strings);
-  });
-}
-
-// src/adapters/mcp/get-logic-slice.ts
-var InputSchema = z.object({
-  symbolId: z.string().min(1).optional(),
-  symbolIds: z.array(z.string().min(1)).optional(),
-  level: DetailLevelSchema.optional().default(3),
-  intent: z.string().optional().describe('Filter dependencies by intent keywords (e.g., "core", "adapter", "storage")')
-}).refine(
-  (data) => data.symbolId || data.symbolIds && data.symbolIds.length > 0,
-  { message: "Either symbolId or symbolIds must be provided" }
-);
-function buildGraphFromStorage(storage) {
-  const graph = new SymbolGraph();
-  for (const sym of storage.getAllSymbols()) {
-    graph.addNode(sym);
-  }
-  for (const edge of storage.getAllEdges()) {
-    graph.addEdge(edge);
-  }
-  return graph;
-}
-function buildGraphAndFilesFromJsonIndex(ctxoRoot) {
-  const reader = new JsonIndexReader(ctxoRoot);
-  const indices = reader.readAll();
-  return { graph: buildGraphFromIndices(indices), indexedFiles: indices.map((fileIndex) => fileIndex.file) };
-}
-function buildGraphFromIndices(indices) {
-  const graph = new SymbolGraph();
-  for (const fileIndex of indices) {
-    for (const sym of fileIndex.symbols) {
-      graph.addNode(sym);
-    }
-  }
-  for (const fileIndex of indices) {
-    for (const edge of fileIndex.edges) {
-      graph.addEdge(edge);
-    }
-  }
-  return graph;
-}
-function getGraphAndFiles(ctxoRoot, storage) {
-  const json = buildGraphAndFilesFromJsonIndex(ctxoRoot);
-  if (json.graph.nodeCount > 0) return json;
-  return { graph: buildGraphFromStorage(storage), indexedFiles: storage.listIndexedFiles() };
-}
-function handleGetLogicSlice(storage, masking, staleness, ctxoRoot = ".ctxo") {
-  const query = new LogicSliceQuery();
-  const formatter = new DetailFormatter();
-  const getGraph = () => getGraphAndFiles(ctxoRoot, storage);
-  const handler = (args) => {
-    try {
-      const parsed = InputSchema.safeParse(args);
-      if (!parsed.success) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
-        };
-      }
-      const { symbolId, symbolIds, level, intent } = parsed.data;
-      const ids = symbolIds ?? (symbolId ? [symbolId] : []);
-      const { graph, indexedFiles } = getGraph();
-      const results = [];
-      for (const id of ids) {
-        const slice = query.getLogicSlice(graph, id);
-        if (slice) {
-          const formatted = formatter.format(slice, level);
-          if (intent && Array.isArray(formatted["dependencies"])) {
-            formatted["dependencies"] = filterByIntent(
-              formatted["dependencies"],
-              intent
-            );
-          }
-          results.push(formatted);
-        } else {
-          results.push({ found: false, symbolId: id, hint: 'Symbol not found. Run "ctxo index".' });
-        }
-      }
-      const responseData = ids.length === 1 ? results[0] : { batch: true, results };
-      const payload = masking.mask(JSON.stringify(wrapResponse(responseData)));
-      const content = [];
-      if (staleness) {
-        const warning = staleness.check(indexedFiles);
-        if (warning) {
-          content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-        }
-      }
-      content.push({ type: "text", text: payload });
-      return { content };
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
-      };
-    }
-  };
-  return handler;
-}
-
-// src/adapters/mcp/get-why-context.ts
-import { z as z2 } from "zod";
-
-// src/core/overlay/snapshot-staleness.ts
-async function buildSnapshotStaleness(storage, git) {
-  const snapshot = storage.readCommunities();
-  if (!snapshot || !snapshot.commitSha || snapshot.commitSha === "nocommit") return void 0;
-  const getHead = git.getHeadSha?.bind(git);
-  const countBetween = git.countCommitsBetween?.bind(git);
-  const head = getHead ? await getHead() : void 0;
-  if (!head) {
-    return { snapshotCommit: snapshot.commitSha };
-  }
-  if (head === snapshot.commitSha) {
-    return {
-      snapshotCommit: snapshot.commitSha,
-      currentHeadCommit: head,
-      commitsBehind: 0
-    };
-  }
-  const behind = countBetween ? await countBetween(snapshot.commitSha) : void 0;
-  const result = {
-    snapshotCommit: snapshot.commitSha,
-    currentHeadCommit: head,
-    ...typeof behind === "number" ? { commitsBehind: behind } : {}
-  };
-  if (typeof behind === "number" && behind > 0) {
-    return {
-      ...result,
-      hint: `Community snapshot is ${behind} commit${behind === 1 ? "" : "s"} behind HEAD. Run \`ctxo index\` to refresh cluster / drift / boundary data.`
-    };
-  }
-  if (behind === void 0) {
-    return {
-      ...result,
-      hint: "Snapshot commit is not reachable from HEAD \u2014 it may have been rebased away. Run `ctxo index` to re-anchor."
-    };
-  }
-  return result;
-}
-
-// src/adapters/mcp/get-why-context.ts
-function graphOf(indices, storage) {
-  const graph = buildGraphFromIndices(indices);
-  return graph.nodeCount > 0 ? graph : buildGraphFromStorage(storage);
-}
-var InputSchema2 = z2.object({
-  symbolId: z2.string().min(1),
-  maxCommits: z2.number().int().min(1).optional()
-});
-function handleGetWhyContext(storage, git, masking, staleness, ctxoRoot = ".ctxo", clusterLabelMasker) {
-  const revertDetector = new RevertDetector();
-  const indexReader = new JsonIndexReader(ctxoRoot);
-  const driftDetector = new DriftDetector();
-  return async (args) => {
-    try {
-      const parsed = InputSchema2.safeParse(args);
-      if (!parsed.success) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
-        };
-      }
-      const { symbolId: inputId, maxCommits } = parsed.data;
-      const indices = indexReader.readAll();
-      const symbolId = storage.getSymbolById(inputId) ? inputId : graphOf(indices, storage).getNode(inputId)?.symbolId;
-      if (!symbolId) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ found: false, hint: 'Symbol not found. Run "ctxo index" to build the codebase index.' }) }]
-        };
-      }
-      const filePath = symbolId.split("::")[0];
-      const fileIndex = indices.find((i) => i.file === filePath);
-      let commitHistory;
-      let antiPatterns;
-      if (fileIndex && fileIndex.intent.length > 0) {
-        commitHistory = fileIndex.intent;
-        antiPatterns = fileIndex.antiPatterns;
-      } else {
-        const commits = await git.getCommitHistory(filePath);
-        commitHistory = commits.map((c) => ({
-          hash: c.hash,
-          message: c.message,
-          date: c.date,
-          kind: "commit"
-        }));
-        antiPatterns = revertDetector.detect(commits);
-      }
-      const limitedHistory = maxCommits ? commitHistory.slice(0, maxCommits) : commitHistory;
-      const responsePayload = {
-        commitHistory: limitedHistory,
-        antiPatternWarnings: antiPatterns
-      };
-      if (antiPatterns.length > 0) {
-        responsePayload.warningBadge = "\u26A0 Anti-pattern detected";
-      }
-      const rawSnapshot = storage.readCommunities();
-      const currentSnapshot = rawSnapshot && clusterLabelMasker?.isEnabled() ? clusterLabelMasker.maskSnapshot(rawSnapshot) : rawSnapshot;
-      if (currentSnapshot) {
-        const history = storage.listCommunityHistory();
-        const drift = driftDetector.detect(currentSnapshot, history);
-        const relevant = drift.events.filter((event) => event.symbolId === symbolId);
-        if (relevant.length > 0 || drift.hint) {
-          responsePayload.driftSignals = {
-            events: relevant,
-            confidence: drift.confidence,
-            snapshotsAvailable: drift.snapshotsAvailable,
-            distinctCommits: drift.distinctCommits,
-            stabilitySummary: drift.stability,
-            ...drift.hint ? { hint: drift.hint } : {}
-          };
-        }
-      }
-      const stalenessMeta = await buildSnapshotStaleness(storage, git);
-      if (stalenessMeta) {
-        responsePayload._meta = { snapshotStaleness: stalenessMeta };
-      }
-      const payload = masking.mask(JSON.stringify(responsePayload));
-      const content = [];
-      if (staleness) {
-        const warning = staleness.check(storage.listIndexedFiles());
-        if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-      }
-      content.push({ type: "text", text: payload });
-      return { content };
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
-      };
-    }
-  };
-}
-
-// src/adapters/mcp/get-change-intelligence.ts
-import { z as z3 } from "zod";
-
-// src/core/change-intelligence/churn-analyzer.ts
-var ChurnAnalyzer = class {
-  normalize(commitCount, maxCommitCount) {
-    if (maxCommitCount <= 0) return 0;
-    if (commitCount < 0) {
-      throw new Error(`Invalid commit count: ${commitCount}`);
-    }
-    return Math.min(commitCount / maxCommitCount, 1);
-  }
-};
-
-// src/core/change-intelligence/health-scorer.ts
-var HealthScorer = class {
-  score(symbolId, complexity, churn) {
-    const composite = complexity * churn;
-    const band = this.toBand(composite);
-    return { symbolId, complexity, churn, composite, band };
-  }
-  toBand(composite) {
-    if (composite < 0.3) return "low";
-    if (composite < 0.7) return "medium";
-    return "high";
-  }
-};
-
-// src/adapters/mcp/get-change-intelligence.ts
-var InputSchema3 = z3.object({
-  symbolId: z3.string().min(1)
-});
-function handleGetChangeIntelligence(storage, git, masking, staleness, ctxoRoot = ".ctxo") {
-  const churnAnalyzer = new ChurnAnalyzer();
-  const healthScorer = new HealthScorer();
-  const indexReader = new JsonIndexReader(ctxoRoot);
-  return async (args) => {
-    try {
-      const parsed = InputSchema3.safeParse(args);
-      if (!parsed.success) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
-        };
-      }
-      const { symbolId } = parsed.data;
-      const symbol = storage.getSymbolById(symbolId);
-      if (!symbol) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ found: false, hint: 'Symbol not found. Run "ctxo index" to build the codebase index.' }) }]
-        };
-      }
-      const filePath = symbolId.split("::")[0];
-      const normalizePath = (p) => p.replace(/\\/g, "/");
-      const allFiles = storage.listIndexedFiles();
-      const churnResults = await Promise.all(allFiles.map((f) => git.getFileChurn(f)));
-      const maxChurn = Math.max(1, ...churnResults.map((c) => c.commitCount));
-      const targetChurn = churnResults.find((c) => normalizePath(c.filePath) === normalizePath(filePath));
-      const commitCount = targetChurn?.commitCount ?? 0;
-      const normalizedChurn = churnAnalyzer.normalize(commitCount, maxChurn);
-      const indices = indexReader.readAll();
-      const fileIndex = indices.find((i) => i.file === filePath);
-      const complexityEntries = fileIndex?.complexity ?? [];
-      const indexMissingWarning = !fileIndex ? `JSON index for ${filePath} not found on disk \u2014 complexity falls back to 0. Run "ctxo index" to resync.` : void 0;
-      let cyclomatic = complexityEntries.find((c) => c.symbolId === symbolId)?.cyclomatic;
-      if (cyclomatic === void 0) {
-        const symbolName = symbolId.split("::")[1] ?? "";
-        const relatedEntries = complexityEntries.filter(
-          (c) => c.symbolId.startsWith(`${filePath}::${symbolName}.`)
-        );
-        cyclomatic = relatedEntries.length > 0 ? Math.max(...relatedEntries.map((c) => c.cyclomatic)) : 1;
-      }
-      const normalizedComplexity = Math.min((cyclomatic - 1) / 9, 1);
-      const score = healthScorer.score(symbolId, normalizedComplexity, normalizedChurn);
-      const payload = masking.mask(JSON.stringify(score));
-      const content = [];
-      if (staleness) {
-        const warning = staleness.check(storage.listIndexedFiles());
-        if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-      }
-      if (indexMissingWarning) {
-        content.push({ type: "text", text: `\u26A0\uFE0F ${indexMissingWarning}` });
-      }
-      content.push({ type: "text", text: payload });
-      return { content };
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
-      };
-    }
-  };
-}
-
-// src/adapters/mcp/get-blast-radius.ts
-import { z as z4 } from "zod";
-function computeClusterBreakdown(snapshot, rootSymbolId, impactedSymbolIds) {
-  if (impactedSymbolIds.length === 0) return void 0;
-  const assignment = /* @__PURE__ */ new Map();
-  for (const entry of snapshot.communities) {
-    assignment.set(entry.symbolId, { id: entry.communityId, label: entry.communityLabel });
-  }
-  const rootCluster = assignment.get(rootSymbolId);
-  const byCluster = {};
-  let crossClusterCount = 0;
-  for (const symbolId of impactedSymbolIds) {
-    const cluster = assignment.get(symbolId);
-    if (!cluster) continue;
-    const label = cluster.label || `community-${cluster.id}`;
-    byCluster[label] = (byCluster[label] ?? 0) + 1;
-    if (rootCluster && cluster.id !== rootCluster.id) crossClusterCount++;
-  }
-  const clusterCount = Object.keys(byCluster).length;
-  const multiClusterHint = clusterCount >= 3 ? `Change impacts ${clusterCount} clusters \u2014 multi-team review recommended.` : void 0;
-  return { byCluster, crossClusterCount, multiClusterHint };
-}
-var InputSchema4 = z4.object({
-  symbolId: z4.string().min(1),
-  confidence: z4.enum(["confirmed", "likely", "potential"]).optional(),
-  intent: z4.string().optional().describe('Filter results by intent keywords (e.g., "test", "adapter", "security")')
-});
-function handleGetBlastRadius(storage, masking, staleness, ctxoRoot = ".ctxo", git, clusterLabelMasker, coChange) {
-  const calculator = new BlastRadiusCalculator();
-  const getGraph = () => getGraphAndFiles(ctxoRoot, storage);
-  return async (args) => {
-    try {
-      const parsed = InputSchema4.safeParse(args);
-      if (!parsed.success) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
-        };
-      }
-      const { symbolId } = parsed.data;
-      const { graph, indexedFiles } = getGraph();
-      const root = graph.getNode(symbolId);
-      if (!root) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ found: false, hint: 'Symbol not found. Run "ctxo index" to build the codebase index.' }) }]
-        };
-      }
-      const rootId = root.symbolId;
-      const coChangeMap = coChange?.readCoChangeMap();
-      const result = calculator.calculate(graph, rootId, coChangeMap);
-      let symbols = result.impactedSymbols;
-      if (parsed.data.confidence) {
-        symbols = symbols.filter((s) => s.confidence === parsed.data.confidence);
-      }
-      symbols = filterByIntent(symbols, parsed.data.intent);
-      const confirmedCount = symbols.filter((s) => s.confidence === "confirmed").length;
-      const likelyCount = symbols.filter((s) => s.confidence === "likely").length;
-      const potentialCount = symbols.filter((s) => s.confidence === "potential").length;
-      const rawSnapshot = storage.readCommunities();
-      const snapshot = rawSnapshot && clusterLabelMasker?.isEnabled() ? clusterLabelMasker.maskSnapshot(rawSnapshot) : rawSnapshot;
-      const clusterBreakdown = snapshot ? computeClusterBreakdown(snapshot, rootId, symbols.map((s) => s.symbolId)) : void 0;
-      const body = {
-        symbolId,
-        impactScore: symbols.length,
-        directDependentsCount: result.directDependentsCount,
-        confirmedCount,
-        likelyCount,
-        potentialCount,
-        overallRiskScore: result.overallRiskScore,
-        impactedSymbols: symbols
-      };
-      if (clusterBreakdown) {
-        body.byCluster = clusterBreakdown.byCluster;
-        body.crossClusterEdges = clusterBreakdown.crossClusterCount;
-        if (clusterBreakdown.multiClusterHint) {
-          body.multiClusterHint = clusterBreakdown.multiClusterHint;
-        }
-      }
-      const coChangedFiles = findCoChangedFilesForBlastRadius(coChangeMap, rootId, result.impactedSymbols);
-      if (coChangedFiles.length > 0) body.coChangedFiles = coChangedFiles;
-      const stalenessMeta = git ? await buildSnapshotStaleness(storage, git) : void 0;
-      const extras = stalenessMeta ? { snapshotStaleness: stalenessMeta } : void 0;
-      const payload = masking.mask(JSON.stringify(wrapResponse(body, extras)));
-      const content = [];
-      if (staleness) {
-        const warning = staleness.check(indexedFiles);
-        if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-      }
-      content.push({ type: "text", text: payload });
-      return { content };
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
-      };
-    }
-  };
-}
-
-// src/adapters/mcp/get-architectural-overlay.ts
-import { z as z5 } from "zod";
-var OVERLAY_MODES = ["regex", "communities", "both", "contexts"];
-var InputSchema5 = z5.object({
-  layer: z5.string().optional(),
-  mode: z5.enum(OVERLAY_MODES).optional(),
-  candidate: z5.number().int().positive().optional()
-});
-function buildCommunityOverlay(snapshot, options = {}) {
-  const previewLimit = options.memberPreviewLimit ?? 15;
-  const byCluster = /* @__PURE__ */ new Map();
-  for (const entry of snapshot.communities) {
-    const list = byCluster.get(entry.communityId) ?? [];
-    list.push(entry.symbolId);
-    byCluster.set(entry.communityId, list);
-  }
-  const labelFor = /* @__PURE__ */ new Map();
-  for (const entry of snapshot.communities) {
-    if (!labelFor.has(entry.communityId)) {
-      labelFor.set(entry.communityId, entry.communityLabel);
-    }
-  }
-  const godNodesByCommunity = /* @__PURE__ */ new Map();
-  for (const god of snapshot.godNodes) {
-    for (const communityId of god.bridgedCommunities) {
-      const set = godNodesByCommunity.get(communityId) ?? /* @__PURE__ */ new Set();
-      set.add(god.symbolId);
-      godNodesByCommunity.set(communityId, set);
-    }
-  }
-  const clusters = [];
-  for (const [id, members] of byCluster) {
-    members.sort();
-    clusters.push({
-      id,
-      label: labelFor.get(id) ?? `community-${id}`,
-      memberCount: members.length,
-      members: members.slice(0, previewLimit),
-      godNodes: [...godNodesByCommunity.get(id) ?? []].sort()
-    });
-  }
-  clusters.sort((a, b) => b.memberCount - a.memberCount || a.id - b.id);
-  return {
-    clusters,
-    modularity: snapshot.modularity,
-    edgeQuality: snapshot.edgeQuality,
-    crossClusterEdges: snapshot.crossClusterEdges,
-    computedAt: snapshot.computedAt,
-    commitSha: snapshot.commitSha
-  };
-}
-var HUB_COLLISION_LIMIT = 50;
-var SUMMARY_TERM_LIMIT = 5;
-var DETAIL_FILE_LIMIT = 15;
-var DETAIL_COLLISION_LIMIT = 10;
-var DETAIL_OCCURRENCE_LIMIT = 5;
-var DETAIL_DATA_LIMIT = 15;
-var DETAIL_ACCESS_LIMIT = 10;
-var NO_VIEW_HINT = "No contexts view available. Run ctxo index to generate one.";
-var SUMMARY_HINT = "Pass candidate: <id> for one candidate in full; run ctxo contexts --json for the whole view.";
-var DETAIL_HINT = "Run ctxo contexts --json for full member sets.";
-function labelMaskerFor(view, labelMasker) {
-  const masker = labelMasker?.isEnabled() ? labelMasker : void 0;
-  if (!masker) return (label) => label;
-  for (const label of [...new Set(view.candidates.map((c) => c.label))].sort(compareCodepoint)) masker.mask(label);
-  return (label) => masker.mask(label);
-}
-function collisionSummary(collision) {
-  return {
-    name: collision.name,
-    minJaccard: collision.minJaccard,
-    candidates: [...new Set(collision.occurrences.map((occurrence) => occurrence.candidate))].sort((a, b) => a - b),
-    occurrenceCount: collision.occurrences.length
-  };
-}
-function contextsSummary(view, maskLabel) {
-  return {
-    commitSha: view.commitSha,
-    coverage: view.coverage,
-    candidates: view.candidates.map((candidate) => ({
-      id: candidate.id,
-      label: maskLabel(candidate.label),
-      fingerprint: candidate.fingerprint,
-      fileCount: candidate.fileCount,
-      cohesion: candidate.cohesion,
-      topTerms: candidate.topTerms.slice(0, SUMMARY_TERM_LIMIT),
-      ...candidate.sharedTables.length > 0 ? { sharedTableCount: candidate.sharedTables.length } : {}
-    })),
-    hubs: view.hubs.slice(0, HUB_COLLISION_LIMIT).map((hub) => ({
-      file: hub.file,
-      reasons: hub.reasons,
-      ...hub.candidate !== void 0 ? { candidate: hub.candidate } : {}
-    })),
-    hubsTotal: view.hubs.length,
-    collisions: view.collisions.slice(0, HUB_COLLISION_LIMIT).map(collisionSummary),
-    collisionsTotal: view.collisions.length,
-    unclustered: { count: view.unclustered.count },
-    dataResourcesTotal: view.dataResources.length,
-    sharedResourcesTotal: view.dataResources.filter((resource) => resource.accesses.length >= 2).length,
-    externalResourcesTotal: view.dataResources.filter((resource) => resource.external).length,
-    hint: SUMMARY_HINT
-  };
-}
-function sharedTableDetail(table, id) {
-  const own = table.accesses.filter((access) => access.candidate === id);
-  const others = table.accesses.filter((access) => access.candidate !== id).slice(0, DETAIL_ACCESS_LIMIT - own.length);
-  return {
-    ...table,
-    accesses: [...own, ...others].sort((a, b) => a.candidate - b.candidate),
-    accessCount: table.accesses.length
-  };
-}
-function ownDataResources(view, id) {
-  const own = [];
-  for (const resource of view.dataResources) {
-    const access = resource.accesses.find((entry) => entry.candidate === id);
-    if (!access) continue;
-    own.push({
-      name: resource.name,
-      ...resource.kind !== void 0 ? { kind: resource.kind } : {},
-      external: resource.external,
-      modes: access.modes,
-      ...resource.owner !== void 0 ? { owner: resource.owner } : {},
-      writerCount: resource.writers.length
-    });
-  }
-  return own;
-}
-function contextsDetail(view, id, maskLabel, extras) {
-  const candidate = view.candidates.find((c) => c.id === id);
-  if (!candidate) {
-    return { found: false, hint: `No candidate ${id} in the contexts view. Call without candidate for the list.` };
-  }
-  const hubs = view.hubs.filter((hub) => hub.candidate === id);
-  const collisions = view.collisions.filter(
-    (collision) => collision.occurrences.some((occurrence) => occurrence.candidate === id)
-  );
-  const dataResources = ownDataResources(view, id);
-  const shownTables = candidate.sharedTables.slice(0, DETAIL_DATA_LIMIT).map((table) => sharedTableDetail(table, id));
-  const shownResources = dataResources.slice(0, DETAIL_DATA_LIMIT);
-  const body = {
-    commitSha: view.commitSha,
-    candidate: {
-      ...candidate,
-      label: maskLabel(candidate.label),
-      files: candidate.files.slice(0, DETAIL_FILE_LIMIT),
-      sharedTables: shownTables,
-      sharedTableCount: candidate.sharedTables.length
-    },
-    hubs: hubs.slice(0, HUB_COLLISION_LIMIT).map((hub) => ({ file: hub.file, reasons: hub.reasons, dependents: hub.dependents, damping: hub.damping })),
-    hubsTotal: hubs.length,
-    collisions: collisions.slice(0, DETAIL_COLLISION_LIMIT).map((collision) => ({
-      ...collisionSummary(collision),
-      occurrences: collision.occurrences.filter((occurrence) => occurrence.candidate === id).slice(0, DETAIL_OCCURRENCE_LIMIT).map((occurrence) => ({
-        symbolId: occurrence.symbolId,
-        members: occurrence.members.slice(0, DETAIL_OCCURRENCE_LIMIT),
-        memberCount: occurrence.members.length
-      }))
-    })),
-    collisionsTotal: collisions.length,
-    dataResources: shownResources,
-    dataResourcesTotal: dataResources.length,
-    hint: DETAIL_HINT
-  };
-  fitDataToLimit(body, shownTables, shownResources, extras);
-  return body;
-}
-function fitDataToLimit(body, tables, resources, extras) {
-  const limit = getThreshold();
-  const size = () => Buffer.byteLength(JSON.stringify(wrapResponse(body, extras)), "utf-8");
-  while ((tables.length > 0 || resources.length > 0) && size() > limit) {
-    if (resources.length >= tables.length) resources.pop();
-    else tables.pop();
-  }
-}
-function buildContextsOverlay(view, options = {}) {
-  if (!view) return { found: false, hint: NO_VIEW_HINT };
-  const maskLabel = labelMaskerFor(view, options.labelMasker);
-  return options.candidate === void 0 ? contextsSummary(view, maskLabel) : contextsDetail(view, options.candidate, maskLabel, options.extras);
-}
-function handleGetArchitecturalOverlay(storage, masking, staleness, git, clusterLabelMasker, contextsView) {
-  const overlay = new ArchitecturalOverlay();
-  return async (args) => {
-    try {
-      const parsed = InputSchema5.safeParse(args);
-      if (!parsed.success) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
-        };
-      }
-      const files = storage.listIndexedFiles();
-      const result = overlay.classify(files);
-      const mode = parsed.data.mode ?? "both";
-      const buildContent = (payloadStr) => {
-        const content = [];
-        if (staleness) {
-          const warning = staleness.check(files);
-          if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-        }
-        content.push({ type: "text", text: payloadStr });
-        return content;
-      };
-      const stalenessMeta = git ? await buildSnapshotStaleness(storage, git) : void 0;
-      const extras = stalenessMeta ? { snapshotStaleness: stalenessMeta } : void 0;
-      if (parsed.data.layer) {
-        const filtered = result.layers[parsed.data.layer];
-        const payload2 = masking.mask(
-          JSON.stringify(wrapResponse({ layer: parsed.data.layer, files: filtered ?? [] }, extras))
-        );
-        return { content: buildContent(payload2) };
-      }
-      if (mode === "contexts") {
-        const body2 = buildContextsOverlay(contextsView?.readContextsView(), {
-          candidate: parsed.data.candidate,
-          labelMasker: clusterLabelMasker,
-          extras
-        });
-        const payload2 = masking.mask(JSON.stringify(wrapResponse(body2, extras)));
-        return { content: buildContent(payload2) };
-      }
-      const rawSnapshot = mode === "regex" ? void 0 : storage.readCommunities();
-      const snapshot = rawSnapshot && clusterLabelMasker?.isEnabled() ? clusterLabelMasker.maskSnapshot(rawSnapshot) : rawSnapshot;
-      const community = snapshot ? buildCommunityOverlay(snapshot) : void 0;
-      const body = {};
-      if (mode !== "communities") body.layers = result.layers;
-      if (community) body.communities = community;
-      if (mode === "communities" && !community) {
-        body.hint = "No community snapshot available. Run `ctxo index` to generate one.";
-      }
-      const payload = masking.mask(JSON.stringify(wrapResponse(body, extras)));
-      return { content: buildContent(payload) };
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
-      };
-    }
-  };
-}
-
-// src/adapters/mcp/get-dead-code.ts
-import { z as z6 } from "zod";
-var InputSchema6 = z6.object({
-  includeTests: z6.boolean().optional().default(false),
-  intent: z6.string().optional().describe('Filter dead code results by intent keywords (e.g., "adapter", "core", "function")')
-});
-function handleFindDeadCode(storage, masking, staleness, ctxoRoot = ".ctxo") {
-  const detector = new DeadCodeDetector();
-  const getGraph = () => getGraphAndFiles(ctxoRoot, storage);
-  return (args) => {
-    try {
-      const parsed = InputSchema6.safeParse(args);
-      if (!parsed.success) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
-        };
-      }
-      const { graph, indexedFiles } = getGraph();
-      const result = detector.detect(graph, { includeTests: parsed.data.includeTests });
-      const filtered = {
-        ...result,
-        deadSymbols: filterByIntent(result.deadSymbols, parsed.data.intent)
-      };
-      const payload = masking.mask(JSON.stringify(wrapResponse(filtered)));
-      const content = [];
-      if (staleness) {
-        const warning = staleness.check(indexedFiles);
-        if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-      }
-      content.push({ type: "text", text: payload });
-      return { content };
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
-      };
-    }
-  };
-}
-
-// src/adapters/mcp/get-context-for-task.ts
-import { z as z7 } from "zod";
-
-// src/core/context-assembly/task-context-strategy.ts
-var TASK_WEIGHTS = {
-  fix: {
-    directDependency: 0.3,
-    interfaceTypeDef: 0.1,
-    blastRadiusDependent: 0.1,
-    highComplexity: 0.2,
-    antiPatternHistory: 0.3
-  },
-  extend: {
-    directDependency: 0.4,
-    interfaceTypeDef: 0.5,
-    blastRadiusDependent: 0.1,
-    highComplexity: 0,
-    antiPatternHistory: 0
-  },
-  refactor: {
-    directDependency: 0.2,
-    interfaceTypeDef: 0.1,
-    blastRadiusDependent: 0.5,
-    highComplexity: 0.1,
-    antiPatternHistory: 0.1
-  },
-  understand: {
-    directDependency: 0.5,
-    interfaceTypeDef: 0.3,
-    blastRadiusDependent: 0.1,
-    highComplexity: 0.1,
-    antiPatternHistory: 0
-  }
-};
-function getWeightsForTask(taskType) {
-  return TASK_WEIGHTS[taskType];
-}
-
-// src/core/context-assembly/context-assembler.ts
-var DEFAULT_TOKEN_BUDGET = 4e3;
-var ContextAssembler = class {
-  logicSlice = new LogicSliceQuery();
-  blastRadius = new BlastRadiusCalculator();
-  /**
-   * `coChangeMap` is the same lookup `get_blast_radius` uses: with it, a potential dependent whose file
-   * co-changes with the target's becomes likely. It changes the tier shown on an entry, not which entries
-   * make the context or how they rank.
-   */
-  assembleForTask(graph, symbolId, taskType, indices, tokenBudget = DEFAULT_TOKEN_BUDGET, coChangeMap) {
-    const target = graph.getNode(symbolId);
-    if (!target) return void 0;
-    const targetId = target.symbolId;
-    const weights = getWeightsForTask(taskType);
-    const slice = this.logicSlice.getLogicSlice(graph, targetId);
-    const blastResult = this.blastRadius.calculate(graph, targetId, coChangeMap);
-    const candidateMap = /* @__PURE__ */ new Map();
-    if (slice) {
-      for (const dep of slice.dependencies) {
-        candidateMap.set(dep.symbolId, {
-          node: dep,
-          signals: { isDirectDep: true, isInterfaceOrType: this.isInterfaceOrType(dep.kind), isDependent: false, complexity: 0, hasAntiPattern: false }
-        });
-      }
-    }
-    for (const entry of blastResult.impactedSymbols) {
-      const node = graph.getNode(entry.symbolId) ?? synthesizeNodeFromId(entry.symbolId);
-      if (!node) continue;
-      const existing = candidateMap.get(entry.symbolId);
-      if (existing) {
-        existing.signals.isDependent = true;
-        existing.signals.dependentConfidence = entry.confidence;
-      } else {
-        candidateMap.set(entry.symbolId, {
-          node,
-          signals: { isDirectDep: false, isInterfaceOrType: this.isInterfaceOrType(node.kind), isDependent: true, dependentConfidence: entry.confidence, complexity: 0, hasAntiPattern: false }
-        });
-      }
-    }
-    const fileIndexMap = new Map(indices.map((i) => [i.file, i]));
-    for (const [sid, candidate] of candidateMap) {
-      const file = sid.split("::")[0] ?? "";
-      const fileIndex = fileIndexMap.get(file);
-      if (fileIndex) {
-        const complexity = fileIndex.complexity?.find((c) => c.symbolId === sid);
-        candidate.signals.complexity = complexity?.cyclomatic ?? 0;
-        candidate.signals.hasAntiPattern = fileIndex.antiPatterns.length > 0;
-      }
-    }
-    const scored = [...candidateMap.entries()].map(([, { node, signals }]) => ({
-      entry: this.buildContextEntry(node, signals, weights),
-      score: this.computeScore(signals, weights)
-    }));
-    scored.sort((a, b) => b.score - a.score);
-    const context = [];
-    let totalTokens = 0;
-    for (const { entry } of scored) {
-      if (totalTokens + entry.tokens > tokenBudget) continue;
-      context.push(entry);
-      totalTokens += entry.tokens;
-    }
-    const warnings = [];
-    const targetFile = targetId.split("::")[0] ?? "";
-    const targetIndex = fileIndexMap.get(targetFile);
-    if (targetIndex && targetIndex.antiPatterns.length > 0) {
-      warnings.push(`\u26A0 Target symbol has ${targetIndex.antiPatterns.length} anti-pattern(s) in file history`);
-    }
-    return { target: withoutAnnotations(target), taskType, context, totalTokens, tokenBudget, warnings };
-  }
-  assembleRanked(graph, query, strategy = "combined", tokenBudget = DEFAULT_TOKEN_BUDGET) {
-    const allNodes = graph.allNodes();
-    const queryLower = query.toLowerCase();
-    let maxReverseEdges = 1;
-    for (const node of allNodes) {
-      const count = graph.getReverseEdges(node.symbolId).length;
-      if (count > maxReverseEdges) maxReverseEdges = count;
-    }
-    const scored = allNodes.map((node) => {
-      const relevanceScore = this.computeTextRelevance(node.name, queryLower);
-      const importanceScore = graph.getReverseEdges(node.symbolId).length / maxReverseEdges;
-      let combinedScore;
-      switch (strategy) {
-        case "dependency":
-          combinedScore = relevanceScore;
-          break;
-        case "importance":
-          combinedScore = importanceScore;
-          break;
-        default:
-          combinedScore = relevanceScore * 0.6 + importanceScore * 0.4;
-      }
-      return {
-        symbolId: node.symbolId,
-        name: node.name,
-        kind: node.kind,
-        file: node.symbolId.split("::")[0] ?? "",
-        relevanceScore: Math.round(relevanceScore * 1e3) / 1e3,
-        importanceScore: Math.round(importanceScore * 1e3) / 1e3,
-        combinedScore: Math.round(combinedScore * 1e3) / 1e3,
-        tokens: this.estimateTokens(node)
-      };
-    });
-    const filtered = strategy === "importance" ? scored : scored.filter((s) => s.relevanceScore > 0 || s.importanceScore > 0.1);
-    filtered.sort((a, b) => b.combinedScore - a.combinedScore);
-    const results = [];
-    let totalTokens = 0;
-    for (const item of filtered) {
-      if (totalTokens + item.tokens > tokenBudget) continue;
-      results.push(item);
-      totalTokens += item.tokens;
-    }
-    return { query, strategy, results, totalTokens, tokenBudget };
-  }
-  computeTextRelevance(name, queryLower) {
-    const nameLower = name.toLowerCase();
-    if (nameLower === queryLower) return 1;
-    if (nameLower.includes(queryLower)) return 0.7;
-    if (queryLower.split(/\s+/).some((word) => nameLower.includes(word))) return 0.4;
-    return 0;
-  }
-  computeScore(signals, weights) {
-    let score = 0;
-    if (signals.isDirectDep) score += weights.directDependency;
-    if (signals.isInterfaceOrType) score += weights.interfaceTypeDef;
-    if (signals.isDependent) score += weights.blastRadiusDependent;
-    if (signals.complexity > 5) score += weights.highComplexity;
-    if (signals.hasAntiPattern) score += weights.antiPatternHistory;
-    return Math.round(score * 1e3) / 1e3;
-  }
-  buildContextEntry(node, signals, weights) {
-    const reasons = [];
-    if (signals.isDirectDep) reasons.push("direct dependency");
-    if (signals.isInterfaceOrType) reasons.push("type/interface definition");
-    if (signals.isDependent) reasons.push("blast radius dependent");
-    if (signals.complexity > 5) reasons.push(`high complexity (CC=${signals.complexity})`);
-    if (signals.hasAntiPattern) reasons.push("anti-pattern history");
-    return {
-      symbolId: node.symbolId,
-      name: node.name,
-      kind: node.kind,
-      file: node.symbolId.split("::")[0] ?? "",
-      relevanceScore: this.computeScore(signals, weights),
-      reason: reasons.join(", ") || "related symbol",
-      lines: node.endLine - node.startLine + 1,
-      tokens: this.estimateTokens(node),
-      ...signals.dependentConfidence ? { confidence: signals.dependentConfidence } : {}
-    };
-  }
-  isInterfaceOrType(kind) {
-    return kind === "interface" || kind === "type";
-  }
-  estimateTokensPublic(node) {
-    return this.estimateTokens(node);
-  }
-  estimateTokens(node) {
-    if (node.startOffset !== void 0 && node.endOffset !== void 0) {
-      return Math.ceil((node.endOffset - node.startOffset) / 4);
-    }
-    return (node.endLine - node.startLine + 1) * 10;
-  }
-};
-var VALID_SYMBOL_KINDS = new Set(SYMBOL_KINDS);
-function synthesizeNodeFromId(symbolId) {
-  const parts = symbolId.split("::");
-  if (parts.length !== 3) return void 0;
-  const [file, name, kindRaw] = parts;
-  if (!file || !name || !kindRaw) return void 0;
-  const kind = VALID_SYMBOL_KINDS.has(kindRaw) ? kindRaw : "variable";
-  return { symbolId, name, kind, startLine: 0, endLine: 0 };
-}
-
-// src/adapters/mcp/get-context-for-task.ts
-var TaskTypeSchema = z7.enum(["fix", "extend", "refactor", "understand"]);
-var InputSchema7 = z7.object({
-  symbolId: z7.string().min(1),
-  taskType: TaskTypeSchema,
-  tokenBudget: z7.number().min(100).optional().default(4e3)
-});
-function handleGetContextForTask(storage, masking, staleness, ctxoRoot = ".ctxo", coChange) {
-  const assembler = new ContextAssembler();
-  const indexReader = new JsonIndexReader(ctxoRoot);
-  const getGraph = () => getGraphAndFiles(ctxoRoot, storage);
-  return (args) => {
-    try {
-      const parsed = InputSchema7.safeParse(args);
-      if (!parsed.success) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
-        };
-      }
-      const { symbolId, taskType, tokenBudget } = parsed.data;
-      const { graph, indexedFiles } = getGraph();
-      const indices = indexReader.readAll();
-      const result = assembler.assembleForTask(graph, symbolId, taskType, indices, tokenBudget, coChange?.readCoChangeMap());
-      if (!result) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ found: false, hint: 'Symbol not found. Run "ctxo index".' }) }]
-        };
-      }
-      const payload = masking.mask(JSON.stringify(wrapResponse(result)));
-      const content = [];
-      if (staleness) {
-        const warning = staleness.check(indexedFiles);
-        if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-      }
-      content.push({ type: "text", text: payload });
-      return { content };
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
-      };
-    }
-  };
-}
-
-// src/adapters/mcp/get-ranked-context.ts
-import { z as z8 } from "zod";
-
-// src/core/search/fuzzy-corrector.ts
-var FuzzyCorrector = class {
-  /** term → frequency (for tie-breaking) */
-  vocabulary = /* @__PURE__ */ new Map();
-  buildVocabulary(termFrequencies) {
-    this.vocabulary = new Map(termFrequencies);
-  }
-  /**
-   * Attempt to correct query tokens.
-   * Returns null if no correction found or no improvement possible.
-   */
-  correct(queryTokens) {
-    if (this.vocabulary.size === 0) return null;
-    const corrections = [];
-    const correctedTokens = [];
-    let anyChanged = false;
-    for (const token of queryTokens) {
-      if (token.length <= 2) {
-        correctedTokens.push(token);
-        continue;
-      }
-      if (this.vocabulary.has(token)) {
-        correctedTokens.push(token);
-        continue;
-      }
-      const maxDist = token.length <= 5 ? 1 : 2;
-      const best = this.findClosest(token, maxDist);
-      if (best) {
-        corrections.push({
-          original: token,
-          corrected: best.term,
-          distance: best.distance
-        });
-        correctedTokens.push(best.term);
-        anyChanged = true;
-      } else {
-        correctedTokens.push(token);
-      }
-    }
-    if (!anyChanged) return null;
-    return {
-      originalQuery: queryTokens.join(" "),
-      correctedQuery: correctedTokens.join(" "),
-      corrections
-    };
-  }
-  /**
-   * Find the closest vocabulary term within maxDistance.
-   * Tie-breaks by frequency (higher = preferred).
-   */
-  findClosest(token, maxDistance) {
-    let bestTerm = null;
-    let bestDist = maxDistance + 1;
-    let bestFreq = -1;
-    for (const [vocabTerm, freq] of this.vocabulary) {
-      if (Math.abs(vocabTerm.length - token.length) > maxDistance) continue;
-      const dist = damerauLevenshtein(token, vocabTerm);
-      if (dist <= maxDistance) {
-        if (dist < bestDist || dist === bestDist && freq > bestFreq) {
-          bestTerm = vocabTerm;
-          bestDist = dist;
-          bestFreq = freq;
-        }
-      }
-    }
-    return bestTerm !== null ? { term: bestTerm, distance: bestDist } : null;
-  }
-};
-function damerauLevenshtein(a, b) {
-  const lenA = a.length;
-  const lenB = b.length;
-  if (lenA === 0) return lenB;
-  if (lenB === 0) return lenA;
-  const d = Array.from({ length: lenA + 1 }, () => new Array(lenB + 1).fill(0));
-  for (let i = 0; i <= lenA; i++) d[i][0] = i;
-  for (let j = 0; j <= lenB; j++) d[0][j] = j;
-  for (let i = 1; i <= lenA; i++) {
-    for (let j = 1; j <= lenB; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      d[i][j] = Math.min(
-        d[i - 1][j] + 1,
-        // deletion
-        d[i][j - 1] + 1,
-        // insertion
-        d[i - 1][j - 1] + cost
-        // substitution
-      );
-      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
-        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + cost);
-      }
-    }
-  }
-  return d[lenA][lenB];
-}
-
-// src/core/search/search-engine.ts
-var log2 = createLogger("ctxo:search");
-var DEFAULT_CONFIG = {
-  bm25: { k1: 1.2, b: 0.25 },
-  pageRankWeight: 0.5,
-  trigramPenalty: 0.8,
-  phase2Threshold: 3,
-  fuzzyThreshold: 3,
-  maxPerPhase: 50
-};
-var SearchEngine = class {
-  config;
-  tokenizer;
-  fuzzy;
-  // Primary index (exact + tokenized)
-  documents = [];
-  primaryIndex = /* @__PURE__ */ new Map();
-  avgDocLength = 0;
-  // Trigram index (character 3-grams)
-  trigramIndex = /* @__PURE__ */ new Map();
-  // PageRank scores
-  pageRankScores = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-    this.tokenizer = new SymbolTokenizer({ includeOriginal: true, includeFilePath: true });
-    this.fuzzy = new FuzzyCorrector();
-  }
-  getTier() {
-    return "in-memory";
-  }
-  buildIndex(symbols, pageRankScores) {
-    const start = performance.now();
-    this.documents = [];
-    this.primaryIndex = /* @__PURE__ */ new Map();
-    this.trigramIndex = /* @__PURE__ */ new Map();
-    this.pageRankScores = pageRankScores ?? /* @__PURE__ */ new Map();
-    let totalLength = 0;
-    const vocabFreq = /* @__PURE__ */ new Map();
-    for (const sym of symbols) {
-      const filePath = sym.symbolId.split("::")[0] ?? "";
-      const tokens = this.tokenizer.tokenize(sym.name, filePath);
-      const doc = {
-        symbolId: sym.symbolId,
-        name: sym.name,
-        kind: sym.kind,
-        filePath,
-        tokens,
-        length: tokens.length
-      };
-      const docIndex = this.documents.length;
-      this.documents.push(doc);
-      totalLength += tokens.length;
-      const termFreqs = /* @__PURE__ */ new Map();
-      for (const token of tokens) {
-        termFreqs.set(token, (termFreqs.get(token) ?? 0) + 1);
-        vocabFreq.set(token, (vocabFreq.get(token) ?? 0) + 1);
-      }
-      for (const [term, tf] of termFreqs) {
-        let postings = this.primaryIndex.get(term);
-        if (!postings) {
-          postings = [];
-          this.primaryIndex.set(term, postings);
-        }
-        postings.push({ docIndex, termFrequency: tf });
-      }
-      const nameLower = sym.name.toLowerCase();
-      const trigrams = this.extractTrigrams(nameLower);
-      const trigramFreqs = /* @__PURE__ */ new Map();
-      for (const tri of trigrams) {
-        trigramFreqs.set(tri, (trigramFreqs.get(tri) ?? 0) + 1);
-      }
-      for (const [tri, tf] of trigramFreqs) {
-        let postings = this.trigramIndex.get(tri);
-        if (!postings) {
-          postings = [];
-          this.trigramIndex.set(tri, postings);
-        }
-        postings.push({ docIndex, termFrequency: tf });
-      }
-    }
-    this.avgDocLength = this.documents.length > 0 ? totalLength / this.documents.length : 1;
-    this.fuzzy.buildVocabulary(vocabFreq);
-    const elapsed = performance.now() - start;
-    log2.info(`Index built: ${symbols.length} symbols, ${this.primaryIndex.size} terms, ${this.trigramIndex.size} trigrams (${elapsed.toFixed(0)}ms)`);
-  }
-  search(query, limit = 50) {
-    const start = performance.now();
-    const queryTokens = this.tokenizer.tokenizeQuery(query);
-    if (queryTokens.length === 0) {
-      return this.emptyResponse(query, start);
-    }
-    const metrics = {
-      porterHits: 0,
-      trigramHits: 0,
-      phase2Activated: false,
-      fuzzyApplied: false,
-      latencyMs: 0
-    };
-    const phase1Scores = this.bm25Search(queryTokens, this.primaryIndex);
-    metrics.porterHits = phase1Scores.size;
-    let allScores = phase1Scores;
-    if (phase1Scores.size < this.config.phase2Threshold) {
-      metrics.phase2Activated = true;
-      const queryLower = query.toLowerCase();
-      if (queryLower.length >= 3) {
-        const queryTrigrams = this.extractTrigrams(queryLower);
-        const phase2Scores = this.bm25Search(queryTrigrams, this.trigramIndex);
-        metrics.trigramHits = phase2Scores.size;
-        allScores = this.mergeScores(phase1Scores, phase2Scores, this.config.trigramPenalty);
-      }
-    }
-    let fuzzyCorrection;
-    if (allScores.size < this.config.fuzzyThreshold) {
-      const correction = this.fuzzy.correct(queryTokens);
-      if (correction) {
-        metrics.fuzzyApplied = true;
-        fuzzyCorrection = correction;
-        const correctedTokens = this.tokenizer.tokenizeQuery(correction.correctedQuery);
-        const fuzzyScores = this.bm25Search(correctedTokens, this.primaryIndex);
-        allScores = this.mergeScores(allScores, fuzzyScores, 0.9);
-        if (allScores.size < this.config.fuzzyThreshold && correction.correctedQuery.length >= 3) {
-          const correctedTrigrams = this.extractTrigrams(correction.correctedQuery.toLowerCase());
-          const fuzzyTrigramScores = this.bm25Search(correctedTrigrams, this.trigramIndex);
-          allScores = this.mergeScores(allScores, fuzzyTrigramScores, this.config.trigramPenalty * 0.9);
-        }
-      }
-    }
-    const rawRelevance = new Map(allScores);
-    const effectiveQueryTerms = fuzzyCorrection ? this.tokenizer.tokenizeQuery(fuzzyCorrection.correctedQuery) : queryTokens;
-    if (effectiveQueryTerms.length >= 2) {
-      for (const [docIdx, score] of allScores) {
-        const doc = this.documents[docIdx];
-        const boost = this.bigramBoost(effectiveQueryTerms, doc.tokens);
-        allScores.set(docIdx, score * boost);
-      }
-    }
-    for (const [docIdx, score] of allScores) {
-      const doc = this.documents[docIdx];
-      const pr = this.pageRankScores.get(doc.symbolId) ?? 0;
-      allScores.set(docIdx, score * (1 + this.config.pageRankWeight * pr));
-    }
-    metrics.latencyMs = performance.now() - start;
-    const results = this.buildResults(allScores, rawRelevance, limit);
-    const phaseInfo = metrics.phase2Activated ? "phase2=yes" : "phase2=no";
-    if (fuzzyCorrection) {
-      log2.info(`search "${query}" \u2192 fuzzy "${fuzzyCorrection.correctedQuery}": ${results.length} results (${metrics.latencyMs.toFixed(0)}ms)`);
-    } else {
-      log2.info(`search "${query}": ${results.length} results, porter=${metrics.porterHits} trigram=${metrics.trigramHits} ${phaseInfo} (${metrics.latencyMs.toFixed(0)}ms)`);
-    }
-    return { query, results, metrics, ...fuzzyCorrection ? { fuzzyCorrection } : {} };
-  }
-  updateFile(filePath, symbols) {
-    const oldIndices = /* @__PURE__ */ new Set();
-    for (let i = 0; i < this.documents.length; i++) {
-      if (this.documents[i].filePath === filePath) {
-        oldIndices.add(i);
-      }
-    }
-    if (oldIndices.size === 0 && symbols.length === 0) return;
-    const allSymbols = [];
-    for (let i = 0; i < this.documents.length; i++) {
-      if (!oldIndices.has(i)) {
-        const doc = this.documents[i];
-        allSymbols.push({
-          symbolId: doc.symbolId,
-          name: doc.name,
-          kind: doc.kind,
-          startLine: 0,
-          endLine: 0
-        });
-      }
-    }
-    allSymbols.push(...symbols);
-    this.buildIndex(allSymbols, this.pageRankScores);
-  }
-  /**
-   * BM25 scoring over an inverted index.
-   * Returns Map<docIndex, score>
-   */
-  bm25Search(queryTerms, index) {
-    const scores = /* @__PURE__ */ new Map();
-    const N = this.documents.length;
-    const { k1, b } = this.config.bm25;
-    for (const term of queryTerms) {
-      const postings = index.get(term);
-      if (!postings) continue;
-      const df = postings.length;
-      const idf = Math.log((N - df + 0.5) / (df + 0.5) + 1);
-      for (const { docIndex, termFrequency } of postings) {
-        const doc = this.documents[docIndex];
-        const tf = termFrequency;
-        const docLen = doc.length;
-        const numerator = tf * (k1 + 1);
-        const denominator = tf + k1 * (1 - b + b * (docLen / this.avgDocLength));
-        const termScore = idf * (numerator / denominator);
-        scores.set(docIndex, (scores.get(docIndex) ?? 0) + termScore);
-      }
-    }
-    const queryJoined = queryTerms.join("");
-    for (const [docIdx, score] of scores) {
-      const doc = this.documents[docIdx];
-      const nameLower = doc.name.toLowerCase();
-      if (nameLower === queryJoined || nameLower === queryTerms.join(" ")) {
-        scores.set(docIdx, score * 5);
-      }
-    }
-    return scores;
-  }
-  /**
-   * Merge two score maps. Phase 2 scores are penalized.
-   */
-  mergeScores(primary, secondary, penalty) {
-    const merged = new Map(primary);
-    for (const [docIdx, score] of secondary) {
-      const existing = merged.get(docIdx);
-      const penalized = score * penalty;
-      if (existing !== void 0) {
-        merged.set(docIdx, Math.max(existing, penalized));
-      } else {
-        merged.set(docIdx, penalized);
-      }
-    }
-    return merged;
-  }
-  /**
-   * Bigram boost for multi-word queries.
-   * Each adjacent query term pair found adjacent in symbol tokens → 2x boost.
-   */
-  bigramBoost(queryTerms, symbolTokens) {
-    if (queryTerms.length < 2) return 1;
-    let adjacentPairs = 0;
-    for (let i = 0; i < queryTerms.length - 1; i++) {
-      const idxA = symbolTokens.findIndex((t) => t.includes(queryTerms[i]));
-      const idxB = symbolTokens.findIndex((t) => t.includes(queryTerms[i + 1]));
-      if (idxA >= 0 && idxB >= 0 && Math.abs(idxA - idxB) === 1) {
-        adjacentPairs++;
-      }
-    }
-    return 1 + adjacentPairs * 2;
-  }
-  /**
-   * Extract character trigrams from a string.
-   * "sqlite" → ["sql", "qli", "lit", "ite"]
-   */
-  extractTrigrams(text) {
-    const trigrams = [];
-    for (let i = 0; i <= text.length - 3; i++) {
-      trigrams.push(text.substring(i, i + 3));
-    }
-    return trigrams;
-  }
-  buildResults(combinedScores, rawRelevance, limit) {
-    const entries = [...combinedScores.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit);
-    return entries.map(([docIdx, combined]) => {
-      const doc = this.documents[docIdx];
-      const pr = this.pageRankScores.get(doc.symbolId) ?? 0;
-      return {
-        symbolId: doc.symbolId,
-        name: doc.name,
-        kind: doc.kind,
-        filePath: doc.filePath,
-        relevanceScore: rawRelevance.get(docIdx) ?? 0,
-        importanceScore: pr,
-        combinedScore: combined
-      };
-    });
-  }
-  emptyResponse(query, start) {
-    return {
-      query,
-      results: [],
-      metrics: {
-        porterHits: 0,
-        trigramHits: 0,
-        phase2Activated: false,
-        fuzzyApplied: false,
-        latencyMs: performance.now() - start
-      }
-    };
-  }
-};
-
-// src/adapters/mcp/get-ranked-context.ts
-var log3 = createLogger("ctxo:search");
-var InputSchema8 = z8.object({
-  query: z8.string().min(1),
-  tokenBudget: z8.number().min(100).optional().default(4e3),
-  strategy: z8.enum(["combined", "dependency", "importance"]).optional().default("combined"),
-  searchMode: z8.enum(["fts", "legacy"]).optional().default("fts")
-});
-function handleGetRankedContext(storage, masking, staleness, ctxoRoot = ".ctxo", searchEngine) {
-  const assembler = new ContextAssembler();
-  const engine = searchEngine ?? new SearchEngine();
-  const getGraph = () => getGraphAndFiles(ctxoRoot, storage);
-  let lastNodeCount = -1;
-  return (args) => {
-    try {
-      const parsed = InputSchema8.safeParse(args);
-      if (!parsed.success) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
-        };
-      }
-      const { query, tokenBudget, strategy, searchMode } = parsed.data;
-      const { graph, indexedFiles } = getGraph();
-      if (searchMode === "fts" && strategy !== "importance") {
-        const currentNodeCount = graph.nodeCount;
-        if (currentNodeCount !== lastNodeCount) {
-          const allNodes = graph.allNodes();
-          const pageRankScores = /* @__PURE__ */ new Map();
-          let maxReverseEdges = 1;
-          for (const node of allNodes) {
-            const count = graph.getReverseEdges(node.symbolId).length;
-            if (count > maxReverseEdges) maxReverseEdges = count;
-          }
-          for (const node of allNodes) {
-            const count = graph.getReverseEdges(node.symbolId).length;
-            pageRankScores.set(node.symbolId, count / maxReverseEdges);
-          }
-          engine.buildIndex(allNodes, pageRankScores);
-          lastNodeCount = currentNodeCount;
-          log3.info(`Search engine: ${engine.getTier()} (${allNodes.length} symbols)`);
-        }
-        const searchResult = engine.search(query, 100);
-        const results = [];
-        let totalTokens = 0;
-        for (const sr of searchResult.results) {
-          const node = graph.getNode(sr.symbolId);
-          const tokens = node ? assembler.estimateTokensPublic(node) : 90;
-          if (totalTokens + tokens > tokenBudget) continue;
-          results.push({
-            symbolId: sr.symbolId,
-            name: sr.name,
-            kind: sr.kind,
-            file: sr.filePath,
-            relevanceScore: Math.round(sr.relevanceScore * 1e3) / 1e3,
-            importanceScore: Math.round(sr.importanceScore * 1e3) / 1e3,
-            combinedScore: Math.round(sr.combinedScore * 1e3) / 1e3,
-            tokens
-          });
-          totalTokens += tokens;
-        }
-        const payload2 = masking.mask(JSON.stringify(wrapResponse({
-          query,
-          strategy,
-          results,
-          totalTokens,
-          tokenBudget,
-          searchMetrics: searchResult.metrics,
-          ...searchResult.fuzzyCorrection ? { fuzzyCorrection: searchResult.fuzzyCorrection } : {}
-        })));
-        const content2 = [];
-        if (staleness) {
-          const warning = staleness.check(indexedFiles);
-          if (warning) content2.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-        }
-        content2.push({ type: "text", text: payload2 });
-        return { content: content2 };
-      }
-      const result = assembler.assembleRanked(graph, query, strategy, tokenBudget);
-      const payload = masking.mask(JSON.stringify(wrapResponse(result)));
-      const content = [];
-      if (staleness) {
-        const warning = staleness.check(indexedFiles);
-        if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-      }
-      content.push({ type: "text", text: payload });
-      return { content };
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
-      };
-    }
-  };
-}
-
-// src/adapters/mcp/search-symbols.ts
-import { z as z9 } from "zod";
-var InputSchema9 = z9.object({
-  pattern: z9.string().min(1),
-  kind: SymbolKindSchema.optional(),
-  filePattern: z9.string().optional(),
-  limit: z9.number().int().min(1).max(100).optional().default(25),
-  mode: z9.enum(["regex", "fts"]).optional().default("regex")
-});
-function handleSearchSymbols(storage, masking, staleness, ctxoRoot = ".ctxo", searchEngine) {
-  const engine = searchEngine ?? new SearchEngine();
-  let lastFtsNodeCount = -1;
-  const getGraph = () => getGraphAndFiles(ctxoRoot, storage);
-  return (args) => {
-    try {
-      const parsed = InputSchema9.safeParse(args);
-      if (!parsed.success) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
-        };
-      }
-      const { pattern, kind, filePattern, limit, mode } = parsed.data;
-      const { graph, indexedFiles } = getGraph();
-      const allNodes = graph.allNodes();
-      if (mode === "fts") {
-        if (allNodes.length !== lastFtsNodeCount) {
-          engine.buildIndex(allNodes);
-          lastFtsNodeCount = allNodes.length;
-        }
-        const searchResult = engine.search(pattern, limit);
-        let ftsResults = searchResult.results;
-        if (kind) {
-          ftsResults = ftsResults.filter((r) => r.kind === kind);
-        }
-        if (filePattern) {
-          const fp = filePattern.toLowerCase();
-          ftsResults = ftsResults.filter((r) => r.filePath.toLowerCase().includes(fp));
-        }
-        const results2 = ftsResults.slice(0, limit).map((r) => {
-          const node = graph.getNode(r.symbolId);
-          return {
-            symbolId: r.symbolId,
-            name: r.name,
-            kind: r.kind,
-            file: r.filePath,
-            startLine: node?.startLine ?? 0,
-            endLine: node?.endLine ?? 0,
-            relevanceScore: Math.round(r.relevanceScore * 1e3) / 1e3
-          };
-        });
-        const payload2 = masking.mask(JSON.stringify(wrapResponse({
-          totalMatches: ftsResults.length,
-          results: results2,
-          searchMetrics: searchResult.metrics,
-          ...searchResult.fuzzyCorrection ? { fuzzyCorrection: searchResult.fuzzyCorrection } : {}
-        })));
-        const content2 = [];
-        if (staleness) {
-          const warning = staleness.check(indexedFiles);
-          if (warning) content2.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-        }
-        content2.push({ type: "text", text: payload2 });
-        return { content: content2 };
-      }
-      let matcher;
-      try {
-        const regex = new RegExp(pattern, "i");
-        matcher = (name) => regex.test(name);
-      } catch {
-        const lowerPattern = pattern.toLowerCase();
-        matcher = (name) => name.toLowerCase().includes(lowerPattern);
-      }
-      const matches = allNodes.filter((node) => {
-        if (!matcher(node.name)) return false;
-        if (kind && node.kind !== kind) return false;
-        if (filePattern) {
-          const file = node.symbolId.split("::")[0] ?? "";
-          if (!file.toLowerCase().includes(filePattern.toLowerCase())) return false;
-        }
-        return true;
-      });
-      const results = matches.slice(0, limit).map((node) => ({
-        symbolId: node.symbolId,
-        name: node.name,
-        kind: node.kind,
-        file: node.symbolId.split("::")[0],
-        startLine: node.startLine,
-        endLine: node.endLine
-      }));
-      const payload = masking.mask(JSON.stringify(wrapResponse({
-        totalMatches: matches.length,
-        results
-      })));
-      const content = [];
-      if (staleness) {
-        const warning = staleness.check(indexedFiles);
-        if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-      }
-      content.push({ type: "text", text: payload });
-      return { content };
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
-      };
-    }
-  };
-}
-
-// src/adapters/mcp/get-changed-symbols.ts
-import { z as z10 } from "zod";
-var InputSchema10 = z10.object({
-  since: z10.string().optional().default("HEAD~1"),
-  maxFiles: z10.number().int().min(1).optional().default(50)
-});
-function handleGetChangedSymbols(storage, git, masking, staleness, ctxoRoot = ".ctxo") {
-  const getGraph = () => getGraphAndFiles(ctxoRoot, storage);
-  return async (args) => {
-    try {
-      const parsed = InputSchema10.safeParse(args);
-      if (!parsed.success) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
-        };
-      }
-      const { since, maxFiles } = parsed.data;
-      const changedPaths = await git.getChangedFiles(since);
-      const { graph, indexedFiles } = getGraph();
-      const nodesByFile = /* @__PURE__ */ new Map();
-      for (const node of graph.allNodes()) {
-        const file = node.symbolId.split("::")[0] ?? "";
-        const existing = nodesByFile.get(file) ?? [];
-        existing.push({ symbolId: node.symbolId, name: node.name, kind: node.kind, startLine: node.startLine, endLine: node.endLine });
-        nodesByFile.set(file, existing);
-      }
-      const files = [];
-      let totalSymbols = 0;
-      for (const filePath of changedPaths.slice(0, maxFiles)) {
-        const symbols = nodesByFile.get(filePath);
-        if (symbols && symbols.length > 0) {
-          files.push({ file: filePath, symbols });
-          totalSymbols += symbols.length;
-        }
-      }
-      const payload = masking.mask(JSON.stringify(wrapResponse({
-        since,
-        changedFiles: files.length,
-        changedSymbols: totalSymbols,
-        files
-      })));
-      const content = [];
-      if (staleness) {
-        const warning = staleness.check(indexedFiles);
-        if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-      }
-      content.push({ type: "text", text: payload });
-      return { content };
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
-      };
-    }
-  };
-}
-
-// src/adapters/mcp/find-importers.ts
-import { z as z11 } from "zod";
-var InputSchema11 = z11.object({
-  symbolId: z11.string().min(1),
-  edgeKinds: z11.array(EdgeKindSchema).optional(),
-  transitive: z11.boolean().optional().default(false),
-  maxDepth: z11.number().int().min(1).max(10).optional().default(5),
-  intent: z11.string().optional().describe('Filter results by intent keywords (e.g., "test", "adapter", "core")')
-});
-function handleFindImporters(storage, masking, staleness, ctxoRoot = ".ctxo") {
-  const getGraph = () => getGraphAndFiles(ctxoRoot, storage);
-  return (args) => {
-    try {
-      const parsed = InputSchema11.safeParse(args);
-      if (!parsed.success) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
-        };
-      }
-      const { symbolId, edgeKinds, transitive, maxDepth } = parsed.data;
-      const { graph, indexedFiles } = getGraph();
-      const root = graph.getNode(symbolId);
-      if (!root) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ found: false, hint: 'Symbol not found. Run "ctxo index" to build the codebase index.' }) }]
-        };
-      }
-      const rootId = root.symbolId;
-      const importers = [];
-      if (!transitive) {
-        const reverseEdges = graph.getDependentEdges(rootId);
-        const seen = /* @__PURE__ */ new Map();
-        for (const edge of reverseEdges) {
-          if (edgeKinds && !edgeKinds.includes(edge.kind)) continue;
-          const node = graph.getNode(edge.from);
-          if (node) {
-            const existing = seen.get(node.symbolId);
-            if (existing) {
-              if (!existing.edgeKinds.includes(edge.kind)) {
-                existing.edgeKinds.push(edge.kind);
-              }
-            } else {
-              const entry = {
-                symbolId: node.symbolId,
-                name: node.name,
-                kind: node.kind,
-                file: node.symbolId.split("::")[0] ?? "",
-                edgeKind: edge.kind,
-                edgeKinds: [edge.kind],
-                depth: 1
-              };
-              seen.set(node.symbolId, entry);
-              importers.push(entry);
-            }
-          }
-        }
-      } else {
-        const definitions = graph.dataResourceIdentity(rootId)?.definitions.map((definition) => definition.symbolId) ?? [];
-        const visited = /* @__PURE__ */ new Set([rootId, ...definitions]);
-        const queue = [{ id: rootId, depth: 0 }];
-        while (queue.length > 0) {
-          const current = queue.shift();
-          if (current.depth >= maxDepth) continue;
-          const reverseEdges = graph.getDependentEdges(current.id);
-          for (const edge of reverseEdges) {
-            if (edgeKinds && !edgeKinds.includes(edge.kind)) continue;
-            if (visited.has(edge.from)) continue;
-            visited.add(edge.from);
-            const node = graph.getNode(edge.from);
-            if (node) {
-              const depth = current.depth + 1;
-              importers.push({
-                symbolId: node.symbolId,
-                name: node.name,
-                kind: node.kind,
-                file: node.symbolId.split("::")[0] ?? "",
-                edgeKind: edge.kind,
-                depth
-              });
-              queue.push({ id: edge.from, depth });
-            }
-          }
-        }
-      }
-      importers.sort((a, b) => a.depth - b.depth);
-      const filtered = filterByIntent(importers, parsed.data.intent);
-      const payload = masking.mask(JSON.stringify(wrapResponse({
-        symbolId,
-        importerCount: filtered.length,
-        importers: filtered
-      })));
-      const content = [];
-      if (staleness) {
-        const warning = staleness.check(indexedFiles);
-        if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-      }
-      content.push({ type: "text", text: payload });
-      return { content };
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
-      };
-    }
-  };
-}
-
-// src/adapters/mcp/get-class-hierarchy.ts
-import { z as z12 } from "zod";
-var HIERARCHY_EDGE_KINDS = /* @__PURE__ */ new Set(["extends", "implements"]);
-var InputSchema12 = z12.object({
-  symbolId: z12.string().min(1).optional(),
-  direction: z12.enum(["ancestors", "descendants", "both"]).optional().default("both")
-});
-function handleGetClassHierarchy(storage, masking, staleness, ctxoRoot = ".ctxo") {
-  const getGraph = () => getGraphAndFiles(ctxoRoot, storage);
-  return (args) => {
-    try {
-      const parsed = InputSchema12.safeParse(args);
-      if (!parsed.success) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
-        };
-      }
-      const { symbolId, direction } = parsed.data;
-      const { graph, indexedFiles } = getGraph();
-      if (symbolId) {
-        return handleRooted(graph, symbolId, direction, masking, staleness, indexedFiles);
-      }
-      return handleFull(graph, masking, staleness, indexedFiles);
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
-      };
-    }
-  };
-  function handleRooted(graph, symbolId, direction, maskingPort, stalenessCheck, indexedFiles) {
-    if (!graph.hasNode(symbolId)) {
-      return {
-        content: [{ type: "text", text: JSON.stringify({ found: false, hint: 'Symbol not found. Run "ctxo index" to build the codebase index.' }) }]
-      };
-    }
-    const ancestors = [];
-    const descendants = [];
-    const isHierarchyEdge = (kind) => HIERARCHY_EDGE_KINDS.has(kind);
-    if (direction === "ancestors" || direction === "both") {
-      const visited = /* @__PURE__ */ new Set([symbolId]);
-      const queue = [{ id: symbolId, depth: 0 }];
-      while (queue.length > 0) {
-        const current = queue.shift();
-        for (const edge of graph.getForwardEdges(current.id)) {
-          if (!isHierarchyEdge(edge.kind)) continue;
-          if (visited.has(edge.to)) continue;
-          visited.add(edge.to);
-          const node = graph.getNode(edge.to);
-          if (node) {
-            const depth = current.depth + 1;
-            ancestors.push({
-              symbolId: node.symbolId,
-              name: node.name,
-              kind: node.kind,
-              file: node.symbolId.split("::")[0] ?? "",
-              edgeKind: edge.kind,
-              depth
-            });
-            queue.push({ id: edge.to, depth });
-          }
-        }
-      }
-    }
-    if (direction === "descendants" || direction === "both") {
-      const visited = /* @__PURE__ */ new Set([symbolId]);
-      const queue = [{ id: symbolId, depth: 0 }];
-      while (queue.length > 0) {
-        const current = queue.shift();
-        for (const edge of graph.getReverseEdges(current.id)) {
-          if (!isHierarchyEdge(edge.kind)) continue;
-          if (visited.has(edge.from)) continue;
-          visited.add(edge.from);
-          const node = graph.getNode(edge.from);
-          if (node) {
-            const depth = current.depth + 1;
-            descendants.push({
-              symbolId: node.symbolId,
-              name: node.name,
-              kind: node.kind,
-              file: node.symbolId.split("::")[0] ?? "",
-              edgeKind: edge.kind,
-              depth
-            });
-            queue.push({ id: edge.from, depth });
-          }
-        }
-      }
-    }
-    const result = { symbolId };
-    if (direction === "ancestors" || direction === "both") result.ancestors = ancestors;
-    if (direction === "descendants" || direction === "both") result.descendants = descendants;
-    const payload = maskingPort.mask(JSON.stringify(wrapResponse(result)));
-    const content = [];
-    if (stalenessCheck) {
-      const warning = stalenessCheck.check(indexedFiles);
-      if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-    }
-    content.push({ type: "text", text: payload });
-    return { content };
-  }
-  function handleFull(graph, maskingPort, stalenessCheck, indexedFiles) {
-    const isHierarchyEdge = (kind) => HIERARCHY_EDGE_KINDS.has(kind);
-    const hierarchyEdges = graph.allEdges().filter((e) => isHierarchyEdge(e.kind));
-    const involved = /* @__PURE__ */ new Set();
-    for (const edge of hierarchyEdges) {
-      involved.add(edge.from);
-      involved.add(edge.to);
-    }
-    const sources = new Set(hierarchyEdges.map((e) => e.from));
-    const roots = [...involved].filter((id) => !sources.has(id));
-    const rootSet = roots.length > 0 ? roots : [...involved];
-    function buildTree(rootId, visited2) {
-      const node = graph.getNode(rootId);
-      if (!node) return void 0;
-      visited2.add(rootId);
-      const children = [];
-      for (const edge of graph.getReverseEdges(rootId)) {
-        if (!isHierarchyEdge(edge.kind)) continue;
-        if (visited2.has(edge.from)) continue;
-        const child = buildTree(edge.from, visited2);
-        if (child) {
-          child.edgeKind = edge.kind;
-          children.push(child);
-        }
-      }
-      return {
-        symbolId: node.symbolId,
-        name: node.name,
-        kind: node.kind,
-        file: node.symbolId.split("::")[0] ?? "",
-        children
-      };
-    }
-    const visited = /* @__PURE__ */ new Set();
-    const hierarchies = [];
-    for (const rootId of rootSet) {
-      if (visited.has(rootId)) continue;
-      const tree = buildTree(rootId, visited);
-      if (tree) hierarchies.push(tree);
-    }
-    const payload = maskingPort.mask(JSON.stringify(wrapResponse({
-      hierarchies,
-      totalClasses: involved.size,
-      totalEdges: hierarchyEdges.length
-    })));
-    const content = [];
-    if (stalenessCheck) {
-      const warning = stalenessCheck.check(indexedFiles);
-      if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-    }
-    content.push({ type: "text", text: payload });
-    return { content };
-  }
-}
-
-// src/adapters/mcp/get-symbol-importance.ts
-import { z as z13 } from "zod";
-var InputSchema13 = z13.object({
-  limit: z13.number().int().min(1).max(200).optional().default(25),
-  kind: SymbolKindSchema.optional(),
-  filePattern: z13.string().optional(),
-  damping: z13.number().min(0).max(1).optional().default(0.85)
-});
-function handleGetSymbolImportance(storage, masking, staleness, ctxoRoot = ".ctxo") {
-  const calculator = new PageRankCalculator();
-  const getGraph = () => getGraphAndFiles(ctxoRoot, storage);
-  return (args) => {
-    try {
-      const parsed = InputSchema13.safeParse(args);
-      if (!parsed.success) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
-        };
-      }
-      const { limit, kind, filePattern, damping } = parsed.data;
-      const { graph, indexedFiles } = getGraph();
-      const result = calculator.calculate(graph, { damping, limit: graph.nodeCount, maxIterations: 100 });
-      let filtered = result.rankings;
-      if (kind) {
-        filtered = filtered.filter((e) => e.kind === kind);
-      }
-      if (filePattern) {
-        const lowerPattern = filePattern.toLowerCase();
-        filtered = filtered.filter((e) => e.file.toLowerCase().includes(lowerPattern));
-      }
-      filtered = filtered.slice(0, limit);
-      const payload = masking.mask(JSON.stringify(wrapResponse({
-        rankings: filtered,
-        totalSymbols: result.totalSymbols,
-        iterations: result.iterations,
-        converged: result.converged,
-        damping
-      })));
-      const content = [];
-      if (staleness) {
-        const warning = staleness.check(indexedFiles);
-        if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-      }
-      content.push({ type: "text", text: payload });
-      return { content };
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
-      };
-    }
-  };
-}
-
-// src/adapters/mcp/get-pr-impact.ts
-import { z as z14 } from "zod";
-var InputSchema14 = z14.object({
-  since: z14.string().optional().default("HEAD~1"),
-  maxFiles: z14.number().int().min(1).optional().default(50),
-  confidence: z14.enum(["confirmed", "likely", "potential"]).optional()
-});
-function computeClustersAffected(snapshot, changedSymbolIds) {
-  const totals = /* @__PURE__ */ new Map();
-  for (const entry of snapshot.communities) {
-    if (!changedSymbolIds.has(entry.symbolId)) continue;
-    const existing = totals.get(entry.communityId);
-    if (existing) {
-      existing.count += 1;
-    } else {
-      totals.set(entry.communityId, { label: entry.communityLabel, count: 1 });
-    }
-  }
-  return [...totals.entries()].map(([id, { label, count }]) => ({ id, label, symbolCount: count })).sort((a, b) => b.symbolCount - a.symbolCount || a.id - b.id);
-}
-function handleGetPrImpact(storage, git, masking, staleness, ctxoRoot = ".ctxo", clusterLabelMasker, coChange) {
-  const calculator = new BlastRadiusCalculator();
-  const getGraph = () => getGraphAndFiles(ctxoRoot, storage);
-  return async (args) => {
-    try {
-      const parsed = InputSchema14.safeParse(args);
-      if (!parsed.success) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
-        };
-      }
-      const { since, maxFiles, confidence: confFilter } = parsed.data;
-      const changedPaths = await git.getChangedFiles(since);
-      if (changedPaths.length === 0) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ since, changedFiles: 0, changedSymbols: 0, totalImpact: 0, riskLevel: "low", files: [], summary: { confirmedTotal: 0, likelyTotal: 0, potentialTotal: 0, highRiskSymbols: [] } }) }]
-        };
-      }
-      const { graph, indexedFiles } = getGraph();
-      const coChangeMap = coChange?.readCoChangeMap();
-      const allNodes = graph.allNodes();
-      const nodesByFile = /* @__PURE__ */ new Map();
-      for (const node of allNodes) {
-        const file = node.symbolId.split("::")[0];
-        let list = nodesByFile.get(file);
-        if (!list) {
-          list = [];
-          nodesByFile.set(file, list);
-        }
-        list.push(node);
-      }
-      const limitedPaths = changedPaths.slice(0, maxFiles);
-      let totalImpact = 0;
-      let confirmedTotal = 0;
-      let likelyTotal = 0;
-      let potentialTotal = 0;
-      const highRiskSymbols = [];
-      const files = [];
-      for (const filePath of limitedPaths) {
-        const symbols = nodesByFile.get(filePath);
-        if (!symbols || symbols.length === 0) continue;
-        const fileSymbols = [];
-        for (const sym of symbols) {
-          const result = calculator.calculate(graph, sym.symbolId, coChangeMap);
-          let impacted = result.impactedSymbols;
-          if (confFilter) {
-            impacted = impacted.filter((s) => s.confidence === confFilter);
-          }
-          const impactScore = impacted.length;
-          const confirmed = impacted.filter((s) => s.confidence === "confirmed").length;
-          const likely = impacted.filter((s) => s.confidence === "likely").length;
-          const potential = impacted.filter((s) => s.confidence === "potential").length;
-          totalImpact += impactScore;
-          confirmedTotal += confirmed;
-          likelyTotal += likely;
-          potentialTotal += potential;
-          if (result.overallRiskScore > 0.7) {
-            highRiskSymbols.push(sym.symbolId);
-          }
-          const topImpacted = impacted.sort((a, b) => b.riskScore - a.riskScore).slice(0, 10);
-          fileSymbols.push({
-            symbolId: sym.symbolId,
-            name: sym.name,
-            kind: sym.kind,
-            blast: {
-              impactScore,
-              confirmedCount: confirmed,
-              likelyCount: likely,
-              potentialCount: potential,
-              riskScore: result.overallRiskScore,
-              topImpacted
-            }
-          });
-        }
-        let coChangedWith;
-        if (coChangeMap) {
-          const entries = coChangeMap.get(filePath);
-          if (entries && entries.length > 0) {
-            coChangedWith = [...entries].sort((a, b) => b.frequency - a.frequency).slice(0, 5).map((e) => e.file1 === filePath ? e.file2 : e.file1);
-          }
-        }
-        files.push({
-          file: filePath,
-          symbols: fileSymbols,
-          ...coChangedWith ? { coChangedWith } : {}
-        });
-      }
-      const maxRisk = files.reduce((max, f) => {
-        const fileMax = f.symbols.reduce((m, s) => Math.max(m, s.blast.riskScore), 0);
-        return Math.max(max, fileMax);
-      }, 0);
-      const riskLevel = maxRisk > 0.7 ? "high" : maxRisk > 0.3 ? "medium" : "low";
-      const changedSymbols = files.reduce((sum, f) => sum + f.symbols.length, 0);
-      const rawSnapshot = storage.readCommunities();
-      const snapshot = rawSnapshot && clusterLabelMasker?.isEnabled() ? clusterLabelMasker.maskSnapshot(rawSnapshot) : rawSnapshot;
-      const history = snapshot ? storage.listCommunityHistory() : [];
-      let boundarySection;
-      let clustersAffected;
-      if (snapshot) {
-        const detector = new BoundaryViolationDetector();
-        const violationResult = detector.detect(graph, snapshot, history);
-        const changedSymbolIds = /* @__PURE__ */ new Set();
-        for (const file of files) {
-          for (const sym of file.symbols) changedSymbolIds.add(sym.symbolId);
-        }
-        const relevant = violationResult.violations.filter(
-          (v) => changedSymbolIds.has(v.from.symbolId) || changedSymbolIds.has(v.to.symbolId)
-        );
-        boundarySection = {
-          violations: relevant,
-          confidence: violationResult.confidence,
-          snapshotsAvailable: violationResult.snapshotsAvailable,
-          distinctCommits: violationResult.distinctCommits,
-          ...violationResult.hint ? { hint: violationResult.hint } : {}
-        };
-        clustersAffected = computeClustersAffected(snapshot, changedSymbolIds);
-      }
-      const body = {
-        since,
-        changedFiles: files.length,
-        changedSymbols,
-        totalImpact,
-        riskLevel,
-        files,
-        summary: {
-          confirmedTotal,
-          likelyTotal,
-          potentialTotal,
-          highRiskSymbols: highRiskSymbols.slice(0, 10)
-        }
-      };
-      if (boundarySection) body.boundaryViolations = boundarySection;
-      if (clustersAffected && clustersAffected.length > 0) body.clustersAffected = clustersAffected;
-      const stalenessMeta = await buildSnapshotStaleness(storage, git);
-      const extras = stalenessMeta ? { snapshotStaleness: stalenessMeta } : void 0;
-      const payload = masking.mask(JSON.stringify(wrapResponse(body, extras)));
-      const content = [];
-      if (staleness) {
-        const warning = staleness.check(indexedFiles);
-        if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
-      }
-      content.push({ type: "text", text: payload });
-      return { content };
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
-      };
-    }
-  };
-}
-
-// src/adapters/stats/with-recording.ts
-function withRecording(toolName, handler, recorder) {
-  if (!recorder) return handler;
-  return (args) => {
-    const start = performance.now();
-    const resultOrPromise = handler(args);
-    if (resultOrPromise instanceof Promise) {
-      return resultOrPromise.then((result) => {
-        recordEvent(toolName, args, result, performance.now() - start, recorder);
-        return result;
-      });
-    }
-    const latencyMs = performance.now() - start;
-    recordEvent(toolName, args, resultOrPromise, latencyMs, recorder);
-    return resultOrPromise;
-  };
-}
-function recordEvent(toolName, args, result, latencyMs, recorder) {
-  try {
-    const responseText = result.content.filter((c) => c.type === "text").map((c) => c.text).join("");
-    let truncated = false;
-    try {
-      const parsed = JSON.parse(responseText);
-      truncated = parsed?._meta?.truncated ?? false;
-    } catch {
-    }
-    const responseBytes = Buffer.byteLength(responseText, "utf-8");
-    const rawLevel = args["level"];
-    let detailLevel = null;
-    if (typeof rawLevel === "number" && rawLevel >= 1 && rawLevel <= 4) {
-      detailLevel = `L${rawLevel}`;
-    }
-    const event = {
-      tool: toolName,
-      symbolId: typeof args["symbolId"] === "string" ? args["symbolId"] : null,
-      detailLevel,
-      responseTokens: Math.ceil(responseBytes / 4),
-      responseBytes,
-      latencyMs,
-      truncated
-    };
-    recorder.record(event);
-  } catch {
-  }
-}
-
-// src/core/overlay/cluster-label-masker.ts
-var ClusterLabelMasker = class {
-  matcher;
-  enabled;
-  labelCache = /* @__PURE__ */ new Map();
-  constructor(patterns) {
-    this.enabled = patterns.length > 0;
-    this.matcher = this.enabled ? makeGlobMatcher([...patterns]) : () => false;
-  }
-  isEnabled() {
-    return this.enabled;
-  }
-  mask(label) {
-    if (!this.enabled) return label;
-    if (!this.matcher(label)) return label;
-    const cached = this.labelCache.get(label);
-    if (cached) return cached;
-    const masked = `[masked-cluster-${this.labelCache.size + 1}]`;
-    this.labelCache.set(label, masked);
-    return masked;
-  }
-  maskSnapshot(snapshot) {
-    if (!this.enabled) return snapshot;
-    const uniqueLabels = [...new Set(snapshot.communities.map((c) => c.communityLabel))].sort();
-    for (const label of uniqueLabels) this.mask(label);
-    const maskedCommunities = snapshot.communities.map((entry) => ({
-      ...entry,
-      communityLabel: this.mask(entry.communityLabel)
-    }));
-    const maskedGodNodes = snapshot.godNodes.map((g) => ({ ...g }));
-    return { ...snapshot, communities: maskedCommunities, godNodes: maskedGodNodes };
-  }
-};
-
-// src/index.ts
-var log4 = createLogger("ctxo:mcp");
-function loadMaskingConfig(ctxoRoot) {
-  const jsonConfigPath = join(ctxoRoot, "masking.json");
-  if (existsSync(jsonConfigPath)) {
-    try {
-      const raw = readFileSync(jsonConfigPath, "utf-8");
-      const patterns = JSON.parse(raw);
-      log4.info(`Loaded ${patterns.length} custom masking pattern(s)`);
-      return MaskingPipeline.fromConfig(patterns);
-    } catch (err) {
-      log4.error(`Failed to load masking config: ${err.message}`);
-    }
-  }
-  return new MaskingPipeline();
-}
-function readStatsEnabled(ctxoRoot) {
-  return statsEnabled(loadConfig(ctxoRoot).config);
-}
-var PKG_VERSION = (() => {
-  try {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
-    return pkg.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-})();
+var log = createLogger("ctxo:mcp");
 async function main() {
   const args = process.argv.slice(2);
   const httpPortStr = resolveHttpPort(args, process.env);
   if (!httpPortStr && args.length > 0) {
-    const { CliRouter } = await import("./cli-router-RR4CM62C.js");
+    if (FAST_ROUTE_COMMANDS.has(args[0])) {
+      process.exitCode = await runFastRoute(args, process.cwd());
+      return;
+    }
+    const { CliRouter } = await import("./cli-router-AZCDNX5R.js");
     const router = new CliRouter(process.cwd());
     await router.route(args);
     return;
   }
-  const ctxoRoot = ".ctxo";
-  const workspace = detectWorkspace(process.cwd());
-  setWorkspaceMeta({ root: workspace.root });
-  const storage = new SqliteStorageAdapter(ctxoRoot, { allowProductionPath: true });
-  await storage.init();
-  const masking = loadMaskingConfig(ctxoRoot);
-  const clusterLabelMasker = new ClusterLabelMasker(
-    maskingClusterLabelPatterns(loadConfig(ctxoRoot).config)
-  );
-  const git = new SimpleGitAdapter(process.cwd());
-  const coChange = new CoChangeReader(ctxoRoot);
-  const recorder = readStatsEnabled(ctxoRoot) ? new SessionRecorderAdapter(storage.getDb(), () => storage.persist()) : null;
-  const server = new McpServer({ name: "ctxo", version: PKG_VERSION });
-  const { StalenessDetector } = await import("./staleness-detector-4HJYBQ7Z.js");
-  const staleness = new StalenessDetector(process.cwd(), ctxoRoot);
-  registerTools(server, storage, masking, git, staleness, recorder, ctxoRoot, clusterLabelMasker, coChange);
-  if (httpPortStr) {
-    await startHttpTransport(async () => {
-      const s = new McpServer({ name: "ctxo", version: PKG_VERSION });
-      registerTools(s, storage, masking, git, staleness, recorder, ctxoRoot, clusterLabelMasker, coChange);
-      return s;
-    }, parseInt(httpPortStr, 10));
-  } else {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-  }
-}
-function registerTools(server, storage, masking, git, staleness, recorder, ctxoRoot = ".ctxo", clusterLabelMasker, coChange) {
-  const toolAnnotations = {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: false
-  };
-  const SYMBOL_ID_FORMAT = "format: file::name::kind; a SQL table, view or procedure also as name::kind, for example dbo.loans::table";
-  const logicSliceHandler = withRecording("get_logic_slice", handleGetLogicSlice(storage, masking, staleness, ctxoRoot), recorder);
-  const whyContextHandler = withRecording("get_why_context", handleGetWhyContext(storage, git, masking, staleness, ctxoRoot, clusterLabelMasker), recorder);
-  const changeIntelligenceHandler = withRecording("get_change_intelligence", handleGetChangeIntelligence(storage, git, masking, staleness, ctxoRoot), recorder);
-  server.registerTool(
-    "get_logic_slice",
-    {
-      description: 'Retrieve a symbol and all its transitive dependencies as a Logic-Slice. Use this when you need to UNDERSTAND what a symbol depends on (downstream view). L1=signature only, L2=direct deps, L3=full closure, L4=with token budget and symbol annotations (attributes, columns; only L4 includes them). Use `intent` to filter dependencies by keyword (e.g., "core", "adapter"). All responses include `_meta` with item counts and truncation info. For impact analysis (what BREAKS if this changes), use get_blast_radius instead. For task-specific context, use get_context_for_task.',
-      inputSchema: {
-        symbolId: z15.string().optional().describe(`Single symbol ID (${SYMBOL_ID_FORMAT})`),
-        symbolIds: z15.array(z15.string()).optional().describe("Batch: array of symbol IDs"),
-        level: z15.number().min(1).max(4).optional().default(3).describe("Detail level (L1=signature, L2=direct deps, L3=full closure, L4=with token budget and annotations)"),
-        intent: z15.string().optional().describe('Filter dependencies by intent keywords (e.g., "core", "adapter")')
-      },
-      annotations: toolAnnotations
-    },
-    (args) => logicSliceHandler(args)
-  );
-  server.registerTool(
-    "get_why_context",
-    {
-      description: "Retrieve git commit history intent and anti-pattern warnings (reverts, rollbacks) for a symbol. Use this when you need to understand WHY code was written this way or whether it has a history of problems. Pair with get_change_intelligence for complexity/churn scores.",
-      inputSchema: {
-        symbolId: z15.string().min(1).describe(`The symbol ID (${SYMBOL_ID_FORMAT})`),
-        maxCommits: z15.number().int().min(1).optional().describe("Limit commit history to N most recent commits")
-      },
-      annotations: toolAnnotations
-    },
-    (args) => whyContextHandler(args)
-  );
-  server.registerTool(
-    "get_change_intelligence",
-    {
-      description: "Retrieve complexity x churn composite score for a symbol \u2014 identifies hotspots that are both complex and frequently changed. Use this to prioritize refactoring targets or assess risk before modifying code. For git history details, use get_why_context. For impact scope, use get_blast_radius.",
-      inputSchema: {
-        symbolId: z15.string().min(1).describe("The symbol ID (format: file::name::kind)")
-      },
-      annotations: toolAnnotations
-    },
-    (args) => changeIntelligenceHandler(args)
-  );
-  const blastRadiusHandler = withRecording("get_blast_radius", handleGetBlastRadius(storage, masking, staleness, ctxoRoot, git, clusterLabelMasker, coChange), recorder);
-  server.registerTool(
-    "get_blast_radius",
-    {
-      description: "BEFORE modifying any symbol (a function, class, method or type, or a SQL table, view or procedure), call this to understand impact. Returns every symbol that depends on the target, directly or transitively, with risk scores that fall with depth. Each dependent is in the tier of its strongest edge: confirmed (`calls`, `extends`, `implements` and the data edges `reads`, `writes`, `executes`), likely (co-changed or `uses`), and potential (`imports`). When co-change history exists, `coChangedFiles` lists up to 10 files that often change together with the target's file but have no dependency path to it (informational: not counted in the tiers or risk scores). Use `confidence` to filter by tier, `intent` to filter by keyword. Large results are auto-truncated with `_meta.hint` for drill-in. For what a symbol DEPENDS ON (downstream), use get_logic_slice instead. For full PR-level analysis, use get_pr_impact.",
-      inputSchema: {
-        symbolId: z15.string().min(1).describe(`The symbol ID (${SYMBOL_ID_FORMAT}). Every definition of a SQL object, and its name::kind id, has the same dependents`),
-        confidence: z15.enum(["confirmed", "likely", "potential"]).optional().describe("Filter by confidence tier"),
-        intent: z15.string().optional().describe('Filter impacted symbols by intent keywords (e.g., "test", "adapter")')
-      },
-      annotations: toolAnnotations
-    },
-    (args) => blastRadiusHandler(args)
-  );
-  const overlayHandler = withRecording("get_architectural_overlay", handleGetArchitecturalOverlay(storage, masking, staleness, git, clusterLabelMasker, new ContextsViewReader(ctxoRoot)), recorder);
-  server.registerTool(
-    "get_architectural_overlay",
-    {
-      description: 'Get the project architecture map. mode "both" (default) returns the regex layer map (Domain, Infrastructure, Adapter, Test, Composition, Configuration) plus data-driven Louvain communities; "regex" or "communities" returns one of them. mode "contexts" returns candidate bounded contexts computed by `ctxo index`: file-level clusters of dependencies and co-change with hub files damped. The summary lists every candidate with label, size, cohesion and top terms, plus hubs and name collisions (type names whose shapes differ between candidates). Use this when onboarding to a new codebase, validating layer boundaries, or preparing a context map. For symbol-level analysis, use get_logic_slice or get_blast_radius. Pass candidate: <id> for one candidate in full: its files, cross-candidate edges, co-change pairs, hubs and collisions. The summary also gives each candidate\'s sharedTableCount and the totals dataResourcesTotal, sharedResourcesTotal and externalResourcesTotal. With candidate: <id>, the detail adds sharedTables (SQL tables and views that files of this candidate and at least one other read or write, with access modes per candidate; up to the first 15 by name, each with up to 10 accesses) and the candidate\'s own dataResources (up to the first 15 by name, each with its access modes, writer count, the owning candidate when only one writes it, and an external flag for resources that no .sql file defines). Both lists hold fewer entries when the response limit requires; sharedTableCount and dataResourcesTotal keep the full counts, and ctxo contexts --json has the full lists.',
-      inputSchema: {
-        layer: z15.string().optional().describe("Filter by specific layer name"),
-        mode: z15.enum(OVERLAY_MODES).optional().describe('View to return: "both" (default) layers plus communities, "regex" layer map, "communities" Louvain clusters, "contexts" candidate contexts (file level)'),
-        candidate: z15.number().int().positive().optional().describe('With mode "contexts": the id of one candidate to return in full (files, terms, cross edges, co-change pairs, its hubs and collisions); omit for the summary of all candidates')
-      },
-      annotations: toolAnnotations
-    },
-    (args) => overlayHandler(args)
-  );
-  const deadCodeHandler = withRecording("find_dead_code", handleFindDeadCode(storage, masking, staleness, ctxoRoot), recorder);
-  server.registerTool(
-    "find_dead_code",
-    {
-      description: 'Find unreachable symbols and files that are never imported or called anywhere. Use this during cleanup, refactoring, or before deleting code to confirm it is truly unused. Symbols in .sql files are never reported. Use `intent` to filter results by keyword (e.g., "adapter", "function"). Large results are auto-truncated with `_meta`. For reverse dependency lookup of a specific symbol, use find_importers instead.',
-      inputSchema: {
-        includeTests: z15.boolean().optional().default(false).describe("Include test files in analysis (default: exclude)"),
-        intent: z15.string().optional().describe('Filter dead code results by intent keywords (e.g., "adapter", "function")')
-      },
-      annotations: toolAnnotations
-    },
-    (args) => deadCodeHandler(args)
-  );
-  const contextForTaskHandler = withRecording("get_context_for_task", handleGetContextForTask(storage, masking, staleness, ctxoRoot, coChange), recorder);
-  server.registerTool(
-    "get_context_for_task",
-    {
-      description: 'Get task-optimized context for a symbol based on what you are about to do. Specify taskType: "fix" (bug investigation - includes history + anti-patterns), "extend" (add feature - includes deps + blast radius), "refactor" (restructure - includes importers + complexity), or "understand" (learn - includes full slice + architecture). Context entries that depend on the symbol (its blast radius) carry an optional `confidence` tier: confirmed, likely or potential, where co-change history can raise potential to likely. This is the BEST starting point when you know both the symbol and your intent.',
-      inputSchema: {
-        symbolId: z15.string().min(1).describe(`The symbol ID (${SYMBOL_ID_FORMAT})`),
-        taskType: z15.enum(["fix", "extend", "refactor", "understand"]).describe("Task type determines which context is most relevant"),
-        tokenBudget: z15.number().optional().default(4e3).describe("Max tokens for context (default 4000)")
-      },
-      annotations: toolAnnotations
-    },
-    (args) => contextForTaskHandler(args)
-  );
-  const rankedContextHandler = withRecording("get_ranked_context", handleGetRankedContext(storage, masking, staleness, ctxoRoot), recorder);
-  server.registerTool(
-    "get_ranked_context",
-    {
-      description: "Search and rank symbols by relevance to a natural language query, packed within a token budget. Uses BM25 text matching + PageRank importance scoring. Results include `_meta` with truncation info. Use this when you have a question or topic but do not know which specific symbol to look at. For exact symbol name search, use search_symbols instead.",
-      inputSchema: {
-        query: z15.string().min(1).describe("Search query (matches symbol names)"),
-        tokenBudget: z15.number().optional().default(4e3).describe("Max tokens for results (default 4000)"),
-        strategy: z15.enum(["combined", "dependency", "importance"]).optional().default("combined").describe("Ranking strategy"),
-        searchMode: z15.enum(["fts", "legacy"]).optional().default("fts").describe('"fts" (default): BM25 ranking with camelCase splitting, trigram fallback and typo correction; "legacy": substring matching; strategy "importance" always uses legacy matching')
-      },
-      annotations: toolAnnotations
-    },
-    (args) => rankedContextHandler(args)
-  );
-  const searchSymbolsHandler = withRecording("search_symbols", handleSearchSymbols(storage, masking, staleness, ctxoRoot), recorder);
-  server.registerTool(
-    "search_symbols",
-    {
-      description: "Search symbols by exact name or regex pattern across the codebase index. Use this when you know (part of) the symbol name and need to find its ID for use with other tools. For semantic/relevance-based search, use get_ranked_context instead.",
-      inputSchema: {
-        pattern: z15.string().min(1).describe("Search pattern (substring or regex)"),
-        kind: SymbolKindSchema.optional().describe("Filter by symbol kind (table, view and procedure come from SQL plugins)"),
-        filePattern: z15.string().optional().describe("Filter by file path substring"),
-        limit: z15.number().int().min(1).max(100).optional().default(25).describe("Max results (default 25)"),
-        mode: z15.enum(["regex", "fts"]).optional().default("regex").describe('"regex" (default): case-insensitive regex or substring match on names; "fts": BM25 relevance search')
-      },
-      annotations: toolAnnotations
-    },
-    (args) => searchSymbolsHandler(args)
-  );
-  const changedSymbolsHandler = withRecording("get_changed_symbols", handleGetChangedSymbols(storage, git, masking, staleness, ctxoRoot), recorder);
-  server.registerTool(
-    "get_changed_symbols",
-    {
-      description: "Get symbols in recently changed files based on git diff. Use this to see what was modified in recent commits. For full PR risk assessment (changed symbols + blast radius + co-changes), use get_pr_impact instead.",
-      inputSchema: {
-        since: z15.string().optional().default("HEAD~1").describe("Git ref to diff against (default HEAD~1)"),
-        maxFiles: z15.number().int().min(1).optional().default(50).describe("Max changed files to process (default 50)")
-      },
-      annotations: toolAnnotations
-    },
-    (args) => changedSymbolsHandler(args)
-  );
-  const findImportersHandler = withRecording("find_importers", handleFindImporters(storage, masking, staleness, ctxoRoot), recorder);
-  server.registerTool(
-    "find_importers",
-    {
-      description: 'Find all symbols that import or depend on a given symbol (reverse dependency / "who uses this?"). Use this to check if a symbol is safe to modify or delete. Supports transitive traversal for deep impact chains. Use `intent` to filter by keyword (e.g., "test", "core"). For forward dependencies (what this symbol uses), use get_logic_slice. For aggregated impact with risk scores, use get_blast_radius.',
-      inputSchema: {
-        symbolId: z15.string().min(1).describe(`The symbol ID (${SYMBOL_ID_FORMAT}). Every definition of a SQL object, and its name::kind id, has the same importers`),
-        edgeKinds: z15.array(EdgeKindSchema).optional().describe("Filter by edge kinds (reads, writes and executes are data access)"),
-        transitive: z15.boolean().optional().default(false).describe("Follow transitive reverse edges (default false)"),
-        maxDepth: z15.number().int().min(1).max(10).optional().default(5).describe("Max BFS depth for transitive mode (default 5)"),
-        intent: z15.string().optional().describe('Filter importers by intent keywords (e.g., "test", "core", "adapter")')
-      },
-      annotations: toolAnnotations
-    },
-    (args) => findImportersHandler(args)
-  );
-  const classHierarchyHandler = withRecording("get_class_hierarchy", handleGetClassHierarchy(storage, masking, staleness, ctxoRoot), recorder);
-  server.registerTool(
-    "get_class_hierarchy",
-    {
-      description: "Get class inheritance hierarchy \u2014 ancestors (extends/implements chain) and descendants (subclasses). Use this when working with OOP code to understand type relationships before modifying a base class or interface. For dependency-based relationships (imports/calls), use get_logic_slice or find_importers.",
-      inputSchema: {
-        symbolId: z15.string().min(1).optional().describe("Root symbol ID (omit for full project hierarchy)"),
-        direction: z15.enum(["ancestors", "descendants", "both"]).optional().default("both").describe("Traversal direction (default both)")
-      },
-      annotations: toolAnnotations
-    },
-    (args) => classHierarchyHandler(args)
-  );
-  const symbolImportanceHandler = withRecording("get_symbol_importance", handleGetSymbolImportance(storage, masking, staleness, ctxoRoot), recorder);
-  server.registerTool(
-    "get_symbol_importance",
-    {
-      description: "Rank symbols by structural importance using PageRank centrality on the dependency graph. Use this to identify the most critical symbols in the codebase \u2014 high-PageRank symbols are heavily depended upon and risky to change. For finding unused/unimportant code, use find_dead_code instead.",
-      inputSchema: {
-        limit: z15.number().int().min(1).max(200).optional().default(25).describe("Max results (default 25)"),
-        kind: SymbolKindSchema.optional().describe("Filter by symbol kind (table, view and procedure come from SQL plugins)"),
-        filePattern: z15.string().optional().describe("Filter by file path substring"),
-        damping: z15.number().min(0).max(1).optional().default(0.85).describe("PageRank damping factor (default 0.85)")
-      },
-      annotations: toolAnnotations
-    },
-    (args) => symbolImportanceHandler(args)
-  );
-  const prImpactHandler = withRecording("get_pr_impact", handleGetPrImpact(storage, git, masking, staleness, ctxoRoot, clusterLabelMasker, coChange), recorder);
-  server.registerTool(
-    "get_pr_impact",
-    {
-      description: "Analyze the full impact of a PR or recent changes in a SINGLE call \u2014 combines changed symbols + blast radius + co-change history into one risk assessment. Results include `_meta` with truncation info. Use this FIRST when reviewing a PR or evaluating recent commits. For single-symbol analysis, use get_blast_radius instead.",
-      inputSchema: {
-        since: z15.string().optional().default("HEAD~1").describe("Git ref to diff against (default HEAD~1)"),
-        maxFiles: z15.number().int().min(1).optional().default(50).describe("Max changed files to analyze"),
-        confidence: z15.enum(["confirmed", "likely", "potential"]).optional().describe("Filter impacted symbols by confidence tier")
-      },
-      annotations: toolAnnotations
-    },
-    (args) => prImpactHandler(args)
-  );
-  server.resource("ctxo-status", "ctxo://status", async (uri) => ({
-    contents: [{ uri: uri.href, text: "Ctxo MCP server is running." }]
-  }));
+  const { startMcpServer } = await import("./mcp-server-6YG2QE6E.js");
+  await startMcpServer(httpPortStr ? { httpPort: parseInt(httpPortStr, 10) } : {});
 }
 main().catch((err) => {
-  log4.error("Fatal: %s", err.message);
+  log.error("Fatal: %s", err.message);
   process.exit(1);
 });
 //# sourceMappingURL=index.js.map