@ctxo/cli 0.0.1 → 0.7.0-alpha.0

package/dist/index.js

@@ -0,0 +1,2723 @@
+#!/usr/bin/env node
+import {
+  ArchitecturalOverlay,
+  DeadCodeDetector,
+  PageRankCalculator,
+  RevertDetector,
+  SessionRecorderAdapter,
+  SimpleGitAdapter,
+  SqliteStorageAdapter,
+  SymbolGraph,
+  createLogger,
+  detectWorkspace,
+  loadCoChangeMap
+} from "./chunk-O3L56NY6.js";
+import {
+  DetailLevelSchema,
+  JsonIndexReader
+} from "./chunk-I4TUA7CD.js";
+import "./chunk-7OCVIDC7.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/index.ts
+import { z as z15 } from "zod";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2, 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 + — excludes hex-only git hashes)
+  { regex: /(?<![A-Za-z0-9/+])(?=[A-Za-z0-9/+=]{40}(?![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([symbolId]);
+    const dependencies = [];
+    const collectedEdges = [];
+    const queue = [{ id: 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;
+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: 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: slice.root,
+      dependencies: directDeps,
+      edges: directEdges,
+      level: 2,
+      levelDescription: "L2: Root + direct dependencies (depth 1)"
+    };
+  }
+  formatL3(slice) {
+    return {
+      root: slice.root,
+      dependencies: slice.dependencies,
+      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."
+};
+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) {
+  return workspaceMeta ? { ...base, workspace: workspaceMeta } : base;
+}
+function wrapResponse(data) {
+  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
+      })
+    };
+  }
+  if (!truncatable || truncatable.arr.length <= 1) {
+    return {
+      ...data,
+      _meta: buildMeta({
+        totalItems,
+        returnedItems: totalItems,
+        truncated: false,
+        totalBytes
+      })
+    };
+  }
+  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]
+      })
+    };
+    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
+    })
+  };
+}
+
+// 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();
+  const graph = new SymbolGraph();
+  const indexedFiles = [];
+  for (const fileIndex of indices) {
+    indexedFiles.push(fileIndex.file);
+    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, indexedFiles };
+}
+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";
+var InputSchema2 = z2.object({
+  symbolId: z2.string().min(1),
+  maxCommits: z2.number().int().min(1).optional()
+});
+function handleGetWhyContext(storage, git, masking, staleness, ctxoRoot = ".ctxo") {
+  const revertDetector = new RevertDetector();
+  const indexReader = new JsonIndexReader(ctxoRoot);
+  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, maxCommits } = 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 indices = indexReader.readAll();
+      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 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 ?? [];
+      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}` });
+      }
+      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";
+
+// src/core/blast-radius/blast-radius-calculator.ts
+var CONFIRMED_KINDS = /* @__PURE__ */ new Set(["calls", "extends", "implements"]);
+var LIKELY_KINDS = /* @__PURE__ */ new Set(["uses"]);
+var CONFIDENCE_RANK = {
+  confirmed: 2,
+  likely: 1,
+  potential: 0
+};
+function edgeKindToConfidence(kind) {
+  if (CONFIRMED_KINDS.has(kind)) return "confirmed";
+  if (LIKELY_KINDS.has(kind)) return "likely";
+  return "potential";
+}
+var BlastRadiusCalculator = class {
+  calculate(graph, symbolId, coChangeMap) {
+    if (!graph.hasNode(symbolId)) {
+      return { impactedSymbols: [], directDependentsCount: 0, confirmedCount: 0, likelyCount: 0, potentialCount: 0, overallRiskScore: 0 };
+    }
+    const sourceFile = symbolId.split("::")[0];
+    const visited = /* @__PURE__ */ new Set([symbolId]);
+    const rawEntries = [];
+    const queue = [{ id: symbolId, depth: 0 }];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const reverseEdges = graph.getReverseEdges(current.id);
+      const bestByNode = /* @__PURE__ */ new Map();
+      for (const edge of reverseEdges) {
+        if (visited.has(edge.from)) continue;
+        const conf = edgeKindToConfidence(edge.kind);
+        const existing = bestByNode.get(edge.from);
+        if (!existing) {
+          bestByNode.set(edge.from, { confidence: conf, kinds: /* @__PURE__ */ new Set([edge.kind]) });
+        } else {
+          existing.kinds.add(edge.kind);
+          if (CONFIDENCE_RANK[conf] > CONFIDENCE_RANK[existing.confidence]) {
+            existing.confidence = conf;
+          }
+        }
+      }
+      for (const [nodeId, info] of bestByNode) {
+        visited.add(nodeId);
+        if (!graph.hasNode(nodeId)) continue;
+        const depth = current.depth + 1;
+        const riskScore = 1 / Math.pow(depth, 0.7);
+        let confidence = info.confidence;
+        let coChangeFrequency;
+        if (coChangeMap) {
+          const nodeFile = nodeId.split("::")[0];
+          const coEntries = coChangeMap.get(sourceFile);
+          if (coEntries) {
+            const match = coEntries.find((e) => e.file1 === nodeFile || e.file2 === nodeFile);
+            if (match) {
+              coChangeFrequency = match.frequency;
+              if (confidence === "potential" && match.frequency > 0.5) {
+                confidence = "likely";
+              }
+            }
+          }
+        }
+        rawEntries.push({
+          symbolId: nodeId,
+          depth,
+          riskScore: Math.round(riskScore * 1e3) / 1e3,
+          confidence,
+          edgeKinds: [...info.kinds],
+          coChangeFrequency
+        });
+        queue.push({ id: nodeId, depth });
+      }
+    }
+    const blastSet = new Set(rawEntries.map((e) => e.symbolId));
+    blastSet.add(symbolId);
+    const entries = rawEntries.map((e) => ({
+      ...e,
+      dependentCount: graph.getReverseEdges(e.symbolId).filter((re) => blastSet.has(re.from)).length
+    }));
+    entries.sort((a, b) => a.depth - b.depth);
+    const directDependentsCount = entries.filter((e) => e.depth === 1).length;
+    const totalRisk = entries.reduce((sum, e) => sum + e.riskScore, 0);
+    const overallRiskScore = Math.round(Math.min(totalRisk / Math.max(directDependentsCount, 1), 1) * 1e3) / 1e3;
+    const confirmedCount = entries.filter((e) => e.confidence === "confirmed").length;
+    const likelyCount = entries.filter((e) => e.confidence === "likely").length;
+    const potentialCount = entries.filter((e) => e.confidence === "potential").length;
+    return { impactedSymbols: entries, directDependentsCount, confirmedCount, likelyCount, potentialCount, overallRiskScore };
+  }
+};
+
+// src/adapters/mcp/get-blast-radius.ts
+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") {
+  const calculator = new BlastRadiusCalculator();
+  const getGraph = () => getGraphAndFiles(ctxoRoot, storage);
+  return (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();
+      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 result = calculator.calculate(graph, symbolId);
+      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 payload = masking.mask(JSON.stringify(wrapResponse({
+        symbolId,
+        impactScore: symbols.length,
+        directDependentsCount: result.directDependentsCount,
+        confirmedCount,
+        likelyCount,
+        potentialCount,
+        overallRiskScore: result.overallRiskScore,
+        impactedSymbols: symbols
+      })));
+      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 InputSchema5 = z5.object({
+  layer: z5.string().optional()
+});
+function handleGetArchitecturalOverlay(storage, masking, staleness) {
+  const overlay = new ArchitecturalOverlay();
+  return (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 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;
+      };
+      if (parsed.data.layer) {
+        const filtered = result.layers[parsed.data.layer];
+        const payload2 = masking.mask(JSON.stringify({ layer: parsed.data.layer, files: filtered ?? [] }));
+        return { content: buildContent(payload2) };
+      }
+      const payload = masking.mask(JSON.stringify(result));
+      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();
+  assembleForTask(graph, symbolId, taskType, indices, tokenBudget = DEFAULT_TOKEN_BUDGET) {
+    const target = graph.getNode(symbolId);
+    if (!target) return void 0;
+    const weights = getWeightsForTask(taskType);
+    const slice = this.logicSlice.getLogicSlice(graph, symbolId);
+    const blastResult = this.blastRadius.calculate(graph, symbolId);
+    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);
+      if (!node) continue;
+      const existing = candidateMap.get(entry.symbolId);
+      if (existing) {
+        existing.signals.isDependent = true;
+      } else {
+        candidateMap.set(entry.symbolId, {
+          node,
+          signals: { isDirectDep: false, isInterfaceOrType: this.isInterfaceOrType(node.kind), isDependent: true, 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 = symbolId.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, 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)
+    };
+  }
+  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;
+  }
+};
+
+// 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") {
+  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);
+      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/symbol-tokenizer.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "get",
+  "set",
+  "is",
+  "has",
+  "can",
+  "do",
+  "the",
+  "a",
+  "an",
+  "of",
+  "to",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "not",
+  "no",
+  "or"
+]);
+var DEFAULT_OPTIONS = {
+  includeStopWords: false,
+  includeOriginal: true,
+  includeFilePath: false
+};
+var SymbolTokenizer = class _SymbolTokenizer {
+  options;
+  constructor(options) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  /**
+   * Tokenize a symbol name into searchable tokens.
+   *
+   * Examples:
+   *   "getCoChangeMetrics"    → ["get", "co", "change", "metrics"]  (or without stop words: ["co", "change", "metrics"])
+   *   "SqliteStorageAdapter"  → ["sqlite", "storage", "adapter"]
+   *   "i_storage_port"        → ["i", "storage", "port"]
+   *   "BM25Scorer"            → ["bm", "25", "scorer"]
+   *   "DB_PASSWORD"           → ["db", "password"]
+   */
+  tokenize(symbolName, filePath) {
+    const splitTokens = _SymbolTokenizer.splitName(symbolName);
+    const lowered = splitTokens.map((t) => t.toLowerCase());
+    const tokens = this.options.includeStopWords ? lowered : lowered.filter((t) => !STOP_WORDS.has(t));
+    if (this.options.includeOriginal) {
+      const original = symbolName.toLowerCase();
+      if (!tokens.includes(original)) {
+        tokens.unshift(original);
+      }
+    }
+    if (this.options.includeFilePath && filePath) {
+      const pathTokens = _SymbolTokenizer.tokenizeFilePath(filePath);
+      for (const pt of pathTokens) {
+        if (!tokens.includes(pt)) {
+          tokens.push(pt);
+        }
+      }
+    }
+    return tokens;
+  }
+  /**
+   * Tokenize a search query. Queries use stop words and don't include originals.
+   */
+  tokenizeQuery(query) {
+    const words = query.trim().split(/\s+/);
+    const tokens = [];
+    for (const word of words) {
+      const split = _SymbolTokenizer.splitName(word);
+      for (const t of split) {
+        const lowered = t.toLowerCase();
+        if (lowered.length > 0 && !tokens.includes(lowered)) {
+          tokens.push(lowered);
+        }
+      }
+    }
+    return tokens;
+  }
+  /**
+   * Split a name into constituent words based on naming convention boundaries.
+   *
+   * Rules:
+   *  1. Split on underscores and hyphens (snake_case, kebab-case)
+   *  2. Split on camelCase/PascalCase boundaries (uppercase after lowercase)
+   *  3. Split acronym boundaries (e.g., "HTMLParser" → ["HTML", "Parser"])
+   *  4. Split on digit ↔ letter boundaries
+   */
+  static splitName(name) {
+    if (!name || name.length === 0) return [];
+    const segments = name.split(/[_\-./\\]+/).filter((s) => s.length > 0);
+    const tokens = [];
+    for (const segment of segments) {
+      tokens.push(..._SymbolTokenizer.splitCamelCase(segment));
+    }
+    return tokens.filter((t) => t.length > 0);
+  }
+  /**
+   * Split a single segment on camelCase/PascalCase/digit boundaries.
+   */
+  static splitCamelCase(segment) {
+    const tokens = [];
+    let current = "";
+    for (let i = 0; i < segment.length; i++) {
+      const ch = segment[i];
+      const prev = i > 0 ? segment[i - 1] : "";
+      if (current.length > 0) {
+        const prevIsDigit = isDigit(prev);
+        const currIsDigit = isDigit(ch);
+        if (prevIsDigit !== currIsDigit) {
+          tokens.push(current);
+          current = ch;
+          continue;
+        }
+      }
+      if (current.length > 0 && isLower(prev) && isUpper(ch)) {
+        tokens.push(current);
+        current = ch;
+        continue;
+      }
+      if (current.length > 1 && isUpper(ch) === false && isUpper(prev) && !isDigit(ch)) {
+        const lastChar = current[current.length - 1];
+        if (isUpper(lastChar)) {
+          tokens.push(current.slice(0, -1));
+          current = lastChar + ch;
+          continue;
+        }
+      }
+      current += ch;
+    }
+    if (current.length > 0) {
+      tokens.push(current);
+    }
+    return tokens;
+  }
+  /**
+   * Extract searchable tokens from a file path.
+   * "src/core/search/symbol-tokenizer.ts" → ["src", "core", "search", "symbol", "tokenizer", "ts"]
+   */
+  static tokenizeFilePath(filePath) {
+    const withoutExt = filePath.replace(/\.[^.]+$/, "");
+    const segments = withoutExt.split(/[/\\]+/);
+    const tokens = [];
+    for (const seg of segments) {
+      const parts = seg.split(/[_\-.]+/).filter((s) => s.length > 0);
+      for (const p of parts) {
+        const lowered = p.toLowerCase();
+        if (lowered.length > 0 && !tokens.includes(lowered)) {
+          tokens.push(lowered);
+        }
+      }
+    }
+    return tokens;
+  }
+  /** Check if a token is a stop word */
+  static isStopWord(token) {
+    return STOP_WORDS.has(token.toLowerCase());
+  }
+};
+function isUpper(ch) {
+  return ch >= "A" && ch <= "Z";
+}
+function isLower(ch) {
+  return ch >= "a" && ch <= "z";
+}
+function isDigit(ch) {
+  return ch >= "0" && ch <= "9";
+}
+
+// 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"),
+  fuzzy: z8.boolean().optional().default(true),
+  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: z9.enum(["function", "class", "interface", "method", "variable", "type"]).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(z11.enum(["imports", "calls", "extends", "implements", "uses"])).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();
+      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 importers = [];
+      if (!transitive) {
+        const reverseEdges = graph.getReverseEdges(symbolId);
+        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 visited = /* @__PURE__ */ new Set([symbolId]);
+        const queue = [{ id: symbolId, depth: 0 }];
+        while (queue.length > 0) {
+          const current = queue.shift();
+          if (current.depth >= maxDepth) continue;
+          const reverseEdges = graph.getReverseEdges(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 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) => kind === "extends" || kind === "implements";
+    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) => kind === "extends" || kind === "implements";
+    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: z13.enum(["function", "class", "interface", "method", "variable", "type"]).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";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+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 loadCoChanges(ctxoRoot) {
+  const path = join(ctxoRoot, "index", "co-changes.json");
+  if (!existsSync(path)) return void 0;
+  try {
+    const matrix = JSON.parse(readFileSync(path, "utf-8"));
+    return loadCoChangeMap(matrix);
+  } catch {
+    return void 0;
+  }
+}
+function handleGetPrImpact(storage, git, masking, staleness, ctxoRoot = ".ctxo") {
+  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 = loadCoChanges(ctxoRoot);
+      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 payload = masking.mask(JSON.stringify(wrapResponse({
+        since,
+        changedFiles: files.length,
+        changedSymbols,
+        totalImpact,
+        riskLevel,
+        files,
+        summary: {
+          confirmedTotal,
+          likelyTotal,
+          potentialTotal,
+          highRiskSymbols: highRiskSymbols.slice(0, 10)
+        }
+      })));
+      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/index.ts
+var log4 = createLogger("ctxo:mcp");
+function loadMaskingConfig(ctxoRoot) {
+  const jsonConfigPath = join2(ctxoRoot, "masking.json");
+  if (existsSync2(jsonConfigPath)) {
+    try {
+      const raw = readFileSync2(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) {
+  const configPath = join2(ctxoRoot, "config.yaml");
+  if (!existsSync2(configPath)) return true;
+  try {
+    const raw = readFileSync2(configPath, "utf-8");
+    const match = raw.match(/stats:\s*\n\s*enabled:\s*(true|false)/);
+    if (match) return match[1] !== "false";
+    return true;
+  } catch {
+    return true;
+  }
+}
+var PKG_VERSION = (() => {
+  try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const pkg = JSON.parse(readFileSync2(join2(__dirname, "..", "package.json"), "utf-8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+})();
+async function main() {
+  const args = process.argv.slice(2);
+  const httpPortStr = process.env.CTXO_HTTP_PORT || (args.includes("--http") ? args[args.indexOf("--port") + 1] || "3001" : null);
+  if (!httpPortStr && args.length > 0) {
+    const { CliRouter } = await import("./cli-router-RA4EBMVV.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);
+  await storage.init();
+  const masking = loadMaskingConfig(ctxoRoot);
+  const git = new SimpleGitAdapter(process.cwd());
+  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-HJH52U5W.js");
+  const staleness = new StalenessDetector(process.cwd(), ctxoRoot);
+  registerTools(server, storage, masking, git, staleness, recorder, ctxoRoot);
+  if (httpPortStr) {
+    await startHttpTransport(async () => {
+      const s = new McpServer({ name: "ctxo", version: PKG_VERSION });
+      registerTools(s, storage, masking, git, staleness, recorder, ctxoRoot);
+      return s;
+    }, parseInt(httpPortStr, 10));
+  } else {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+  }
+}
+function registerTools(server, storage, masking, git, staleness, recorder, ctxoRoot = ".ctxo") {
+  const toolAnnotations = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  };
+  const logicSliceHandler = withRecording("get_logic_slice", handleGetLogicSlice(storage, masking, staleness, ctxoRoot), recorder);
+  const whyContextHandler = withRecording("get_why_context", handleGetWhyContext(storage, git, masking, staleness, ctxoRoot), 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. 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 (format: file::name::kind)"),
+        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)"),
+        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 (format: file::name::kind)"),
+        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), recorder);
+  server.registerTool(
+    "get_blast_radius",
+    {
+      description: "BEFORE modifying any function or class, call this to understand impact. Returns all symbols that would break if the target changes, split into confirmed (direct importers), likely (co-changed), and potential (transitive) tiers with 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 (format: file::name::kind)"),
+        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), recorder);
+  server.registerTool(
+    "get_architectural_overlay",
+    {
+      description: "Get the project architectural layer map \u2014 identifies which symbols belong to Domain, Infrastructure, and Adapter layers. Use this when onboarding to a new codebase or validating that a change respects layer boundaries. For symbol-level analysis, use get_logic_slice or get_blast_radius.",
+      inputSchema: {
+        layer: z15.string().optional().describe("Filter by specific layer name")
+      },
+      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. 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), 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 \u2014 includes history + anti-patterns), "extend" (add feature \u2014 includes deps + blast radius), "refactor" (restructure \u2014 includes importers + complexity), or "understand" (learn \u2014 includes full slice + architecture). 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 (format: file::name::kind)"),
+        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")
+      },
+      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: z15.enum(["function", "class", "interface", "method", "variable", "type"]).optional().describe("Filter by symbol kind"),
+        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)")
+      },
+      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 (format: file::name::kind)"),
+        edgeKinds: z15.array(z15.enum(["imports", "calls", "extends", "implements", "uses"])).optional().describe("Filter by edge kinds"),
+        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: z15.enum(["function", "class", "interface", "method", "variable", "type"]).optional().describe("Filter by symbol kind"),
+        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), 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." }]
+  }));
+}
+main().catch((err) => {
+  log4.error("Fatal: %s", err.message);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map