@ctxo/cli 0.13.0 → 0.14.0

package/dist/mcp-server-6YG2QE6E.js

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