ctxo-mcp 0.2.0 → 0.3.1

package/dist/index.js

@@ -2,19 +2,22 @@
 import {
   RevertDetector,
   SimpleGitAdapter,
-  SqliteStorageAdapter
-} from "./chunk-P7JUSY3I.js";
+  SqliteStorageAdapter,
+  createLogger,
+  loadCoChangeMap
+} from "./chunk-XSHNN6PU.js";
 import {
   DetailLevelSchema,
   JsonIndexReader
-} from "./chunk-54ETLIQX.js";
+} from "./chunk-N6GPODUY.js";
+import "./chunk-JIDIH7DS.js";
 
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z6 } from "zod";
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
+import { z as z15 } from "zod";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
 
 // src/core/masking/masking-pipeline.ts
 var DEFAULT_PATTERNS = [
@@ -76,9 +79,9 @@ var SymbolGraph = class {
   edgeSet = /* @__PURE__ */ new Set();
   addNode(node) {
     this.nodes.set(node.symbolId, node);
-    const parts = node.symbolId.split("::");
-    if (parts.length >= 2) {
-      this.nodesByFileAndName.set(`${parts[0]}::${parts[1]}`, node);
+    const [p0, p1] = node.symbolId.split("::");
+    if (p0 !== void 0 && p1 !== void 0) {
+      this.nodesByFileAndName.set(`${p0}::${p1}`, node);
     }
   }
   addEdge(edge) {
@@ -100,18 +103,29 @@ var SymbolGraph = class {
   }
   resolveNodeId(id) {
     if (this.nodes.has(id)) return id;
-    const parts = id.split("::");
-    if (parts.length >= 2) {
-      const fuzzyKey = `${parts[0]}::${parts[1]}`;
+    const [p0, p1] = id.split("::");
+    if (p0 !== void 0 && p1 !== void 0) {
+      const fuzzyKey = `${p0}::${p1}`;
       const match = this.nodesByFileAndName.get(fuzzyKey);
       if (match) return match.symbolId;
+      const jsToTs = p0.replace(/\.js$/, ".ts");
+      if (jsToTs !== p0) {
+        const altKey = `${jsToTs}::${p1}`;
+        const altMatch = this.nodesByFileAndName.get(altKey);
+        if (altMatch) return altMatch.symbolId;
+      }
     }
     return id;
   }
   resolveNodeFuzzy(id) {
-    const parts = id.split("::");
-    if (parts.length >= 2) {
-      return this.nodesByFileAndName.get(`${parts[0]}::${parts[1]}`);
+    const [p0, p1] = id.split("::");
+    if (p0 !== void 0 && p1 !== void 0) {
+      const match = this.nodesByFileAndName.get(`${p0}::${p1}`);
+      if (match) return match;
+      const jsToTs = p0.replace(/\.js$/, ".ts");
+      if (jsToTs !== p0) {
+        return this.nodesByFileAndName.get(`${jsToTs}::${p1}`);
+      }
     }
     return void 0;
   }
@@ -122,7 +136,7 @@ var SymbolGraph = class {
     return this.reverseEdges.get(symbolId) ?? [];
   }
   hasNode(symbolId) {
-    return this.nodes.has(symbolId);
+    return this.nodes.has(symbolId) || this.resolveNodeFuzzy(symbolId) !== void 0;
   }
   get nodeCount() {
     return this.nodes.size;
@@ -252,6 +266,9 @@ var DetailFormatter = class {
     return Math.ceil(chars / 4);
   }
   symbolCharEstimate(node) {
+    if (node.startOffset !== void 0 && node.endOffset !== void 0) {
+      return node.endOffset - node.startOffset;
+    }
     return (node.endLine - node.startLine + 1) * 40;
   }
   truncateToTokenBudget(slice, budget) {
@@ -272,11 +289,142 @@ var DetailFormatter = class {
   }
 };
 
+// src/core/response-envelope.ts
+var DEFAULT_THRESHOLD = 8192;
+var TRUNCATABLE_FIELDS = {
+  impactedSymbols: "Use search_symbols to find specific impacted symbols, or get_blast_radius with a confidence filter.",
+  importers: "Use find_importers with edgeKinds filter or maxDepth to narrow results.",
+  deadSymbols: "Use search_symbols with kind filter to find specific dead symbols.",
+  unusedExports: "Use find_importers to check specific symbols.",
+  results: "Use search_symbols or get_ranked_context with a narrower query.",
+  rankings: "Use get_symbol_importance with kind or filePattern filter to narrow results.",
+  context: "Use get_context_for_task with a smaller tokenBudget.",
+  hierarchies: "Use get_class_hierarchy with a specific symbolId.",
+  scaffolding: "Review the scaffolding markers directly in the listed files.",
+  deadFiles: "Use find_dead_code with includeTests to adjust scope.",
+  files: "Use get_changed_symbols with a narrower since ref or smaller maxFiles."
+};
+function getThreshold() {
+  const env = process.env["CTXO_RESPONSE_LIMIT"];
+  if (env) {
+    const n = parseInt(env, 10);
+    if (!isNaN(n) && n > 0) return n;
+  }
+  return DEFAULT_THRESHOLD;
+}
+function findTruncatableArray(data) {
+  let best = null;
+  for (const [key, value] of Object.entries(data)) {
+    if (Array.isArray(value) && key in TRUNCATABLE_FIELDS) {
+      if (!best || value.length > best.arr.length) {
+        best = { key, arr: value };
+      }
+    }
+  }
+  return best;
+}
+function wrapResponse(data) {
+  const threshold = getThreshold();
+  const fullJson = JSON.stringify(data);
+  const totalBytes = Buffer.byteLength(fullJson, "utf-8");
+  const truncatable = findTruncatableArray(data);
+  const totalItems = truncatable ? truncatable.arr.length : 0;
+  if (totalBytes <= threshold) {
+    return {
+      ...data,
+      _meta: {
+        totalItems,
+        returnedItems: totalItems,
+        truncated: false,
+        totalBytes
+      }
+    };
+  }
+  if (!truncatable || truncatable.arr.length <= 1) {
+    return {
+      ...data,
+      _meta: {
+        totalItems,
+        returnedItems: totalItems,
+        truncated: false,
+        totalBytes
+      }
+    };
+  }
+  let lo = 1;
+  let hi = truncatable.arr.length;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    const trial = {
+      ...data,
+      [truncatable.key]: truncatable.arr.slice(0, mid),
+      _meta: {
+        totalItems,
+        returnedItems: mid,
+        truncated: true,
+        totalBytes,
+        hint: TRUNCATABLE_FIELDS[truncatable.key]
+      }
+    };
+    const size = Buffer.byteLength(JSON.stringify(trial), "utf-8");
+    if (size <= threshold) {
+      lo = mid;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  const hint = TRUNCATABLE_FIELDS[truncatable.key];
+  return {
+    ...data,
+    [truncatable.key]: truncatable.arr.slice(0, lo),
+    _meta: {
+      totalItems,
+      returnedItems: lo,
+      truncated: true,
+      totalBytes,
+      hint
+    }
+  };
+}
+
+// src/core/intent-filter.ts
+function extractKeywords(intent) {
+  return intent.toLowerCase().split(/\s+/).filter((w) => w.length >= 2);
+}
+function matchesAny(keywords, values) {
+  const lower = values.map((v) => v.toLowerCase());
+  return keywords.some((kw) => lower.some((v) => v.includes(kw)));
+}
+function collectMatchableStrings(entry) {
+  const strings = [];
+  for (const key of ["symbolId", "file", "name", "kind", "edgeKind", "reason", "confidence"]) {
+    const v = entry[key];
+    if (typeof v === "string") strings.push(v);
+  }
+  const edgeKinds = entry["edgeKinds"];
+  if (Array.isArray(edgeKinds)) {
+    for (const ek of edgeKinds) {
+      if (typeof ek === "string") strings.push(ek);
+    }
+  }
+  return strings;
+}
+function filterByIntent(items, intent) {
+  if (!intent || intent.trim().length === 0) return items;
+  const keywords = extractKeywords(intent);
+  if (keywords.length === 0) return items;
+  return items.filter((item) => {
+    const strings = collectMatchableStrings(item);
+    return matchesAny(keywords, strings);
+  });
+}
+
 // src/adapters/mcp/get-logic-slice.ts
 var InputSchema = z.object({
   symbolId: z.string().min(1).optional(),
   symbolIds: z.array(z.string().min(1)).optional(),
-  level: DetailLevelSchema.optional().default(3)
+  level: DetailLevelSchema.optional().default(3),
+  intent: z.string().optional().describe('Filter dependencies by intent keywords (e.g., "core", "adapter", "storage")')
 }).refine(
   (data) => data.symbolId || data.symbolIds && data.symbolIds.length > 0,
   { message: "Either symbolId or symbolIds must be provided" }
@@ -323,20 +471,27 @@ function handleGetLogicSlice(storage, masking, staleness, ctxoRoot = ".ctxo") {
           content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
         };
       }
-      const { symbolId, symbolIds, level } = parsed.data;
+      const { symbolId, symbolIds, level, intent } = parsed.data;
       const ids = symbolIds ?? (symbolId ? [symbolId] : []);
       const graph = getGraph();
       const results = [];
       for (const id of ids) {
         const slice = query.getLogicSlice(graph, id);
         if (slice) {
-          results.push(formatter.format(slice, level));
+          const formatted = formatter.format(slice, level);
+          if (intent && Array.isArray(formatted["dependencies"])) {
+            formatted["dependencies"] = filterByIntent(
+              formatted["dependencies"],
+              intent
+            );
+          }
+          results.push(formatted);
         } else {
           results.push({ found: false, symbolId: id, hint: 'Symbol not found. Run "ctxo index".' });
         }
       }
       const responseData = ids.length === 1 ? results[0] : { batch: true, results };
-      const payload = masking.mask(JSON.stringify(responseData));
+      const payload = masking.mask(JSON.stringify(wrapResponse(responseData)));
       const content = [];
       if (staleness) {
         const warning = staleness.check(storage.listIndexedFiles());
@@ -358,7 +513,8 @@ function handleGetLogicSlice(storage, masking, staleness, ctxoRoot = ".ctxo") {
 // src/adapters/mcp/get-why-context.ts
 import { z as z2 } from "zod";
 var InputSchema2 = z2.object({
-  symbolId: z2.string().min(1)
+  symbolId: z2.string().min(1),
+  maxCommits: z2.number().int().min(1).optional()
 });
 function handleGetWhyContext(storage, git, masking, staleness, ctxoRoot = ".ctxo") {
   const revertDetector = new RevertDetector();
@@ -371,7 +527,7 @@ function handleGetWhyContext(storage, git, masking, staleness, ctxoRoot = ".ctxo
           content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
         };
       }
-      const { symbolId } = parsed.data;
+      const { symbolId, maxCommits } = parsed.data;
       const symbol = storage.getSymbolById(symbolId);
       if (!symbol) {
         return {
@@ -396,8 +552,9 @@ function handleGetWhyContext(storage, git, masking, staleness, ctxoRoot = ".ctxo
         }));
         antiPatterns = revertDetector.detect(commits);
       }
+      const limitedHistory = maxCommits ? commitHistory.slice(0, maxCommits) : commitHistory;
       const responsePayload = {
-        commitHistory,
+        commitHistory: limitedHistory,
         antiPatternWarnings: antiPatterns
       };
       if (antiPatterns.length > 0) {
@@ -511,44 +668,97 @@ function handleGetChangeIntelligence(storage, git, masking, staleness, ctxoRoot
 import { z as z4 } from "zod";
 
 // src/core/blast-radius/blast-radius-calculator.ts
+var CONFIRMED_KINDS = /* @__PURE__ */ new Set(["calls", "extends", "implements"]);
+var LIKELY_KINDS = /* @__PURE__ */ new Set(["uses"]);
+var CONFIDENCE_RANK = {
+  confirmed: 2,
+  likely: 1,
+  potential: 0
+};
+function edgeKindToConfidence(kind) {
+  if (CONFIRMED_KINDS.has(kind)) return "confirmed";
+  if (LIKELY_KINDS.has(kind)) return "likely";
+  return "potential";
+}
 var BlastRadiusCalculator = class {
-  calculate(graph, symbolId) {
+  calculate(graph, symbolId, coChangeMap) {
     if (!graph.hasNode(symbolId)) {
-      return { impactedSymbols: [], directDependentsCount: 0, overallRiskScore: 0 };
+      return { impactedSymbols: [], directDependentsCount: 0, confirmedCount: 0, likelyCount: 0, potentialCount: 0, overallRiskScore: 0 };
     }
+    const sourceFile = symbolId.split("::")[0];
     const visited = /* @__PURE__ */ new Set([symbolId]);
-    const entries = [];
+    const rawEntries = [];
     const queue = [{ id: symbolId, depth: 0 }];
     while (queue.length > 0) {
       const current = queue.shift();
       const reverseEdges = graph.getReverseEdges(current.id);
+      const bestByNode = /* @__PURE__ */ new Map();
       for (const edge of reverseEdges) {
         if (visited.has(edge.from)) continue;
-        visited.add(edge.from);
-        if (!graph.hasNode(edge.from)) continue;
+        const conf = edgeKindToConfidence(edge.kind);
+        const existing = bestByNode.get(edge.from);
+        if (!existing) {
+          bestByNode.set(edge.from, { confidence: conf, kinds: /* @__PURE__ */ new Set([edge.kind]) });
+        } else {
+          existing.kinds.add(edge.kind);
+          if (CONFIDENCE_RANK[conf] > CONFIDENCE_RANK[existing.confidence]) {
+            existing.confidence = conf;
+          }
+        }
+      }
+      for (const [nodeId, info] of bestByNode) {
+        visited.add(nodeId);
+        if (!graph.hasNode(nodeId)) continue;
         const depth = current.depth + 1;
         const riskScore = 1 / Math.pow(depth, 0.7);
-        entries.push({
-          symbolId: edge.from,
+        let confidence = info.confidence;
+        let coChangeFrequency;
+        if (coChangeMap) {
+          const nodeFile = nodeId.split("::")[0];
+          const coEntries = coChangeMap.get(sourceFile);
+          if (coEntries) {
+            const match = coEntries.find((e) => e.file1 === nodeFile || e.file2 === nodeFile);
+            if (match) {
+              coChangeFrequency = match.frequency;
+              if (confidence === "potential" && match.frequency > 0.5) {
+                confidence = "likely";
+              }
+            }
+          }
+        }
+        rawEntries.push({
+          symbolId: nodeId,
           depth,
-          dependentCount: graph.getReverseEdges(edge.from).length,
-          riskScore: Math.round(riskScore * 1e3) / 1e3
+          riskScore: Math.round(riskScore * 1e3) / 1e3,
+          confidence,
+          edgeKinds: [...info.kinds],
+          coChangeFrequency
         });
-        queue.push({ id: edge.from, depth });
+        queue.push({ id: nodeId, depth });
       }
     }
+    const blastSet = new Set(rawEntries.map((e) => e.symbolId));
+    blastSet.add(symbolId);
+    const entries = rawEntries.map((e) => ({
+      ...e,
+      dependentCount: graph.getReverseEdges(e.symbolId).filter((re) => blastSet.has(re.from)).length
+    }));
     entries.sort((a, b) => a.depth - b.depth);
     const directDependentsCount = entries.filter((e) => e.depth === 1).length;
     const totalRisk = entries.reduce((sum, e) => sum + e.riskScore, 0);
-    const maxPossibleRisk = entries.length > 0 ? entries.length : 1;
-    const overallRiskScore = Math.round(Math.min(totalRisk / maxPossibleRisk, 1) * 1e3) / 1e3;
-    return { impactedSymbols: entries, directDependentsCount, overallRiskScore };
+    const overallRiskScore = Math.round(Math.min(totalRisk / Math.max(directDependentsCount, 1), 1) * 1e3) / 1e3;
+    const confirmedCount = entries.filter((e) => e.confidence === "confirmed").length;
+    const likelyCount = entries.filter((e) => e.confidence === "likely").length;
+    const potentialCount = entries.filter((e) => e.confidence === "potential").length;
+    return { impactedSymbols: entries, directDependentsCount, confirmedCount, likelyCount, potentialCount, overallRiskScore };
   }
 };
 
 // src/adapters/mcp/get-blast-radius.ts
 var InputSchema4 = z4.object({
-  symbolId: z4.string().min(1)
+  symbolId: z4.string().min(1),
+  confidence: z4.enum(["confirmed", "likely", "potential"]).optional(),
+  intent: z4.string().optional().describe('Filter results by intent keywords (e.g., "test", "adapter", "security")')
 });
 function handleGetBlastRadius(storage, masking, staleness, ctxoRoot = ".ctxo") {
   const calculator = new BlastRadiusCalculator();
@@ -573,13 +783,24 @@ function handleGetBlastRadius(storage, masking, staleness, ctxoRoot = ".ctxo") {
         };
       }
       const result = calculator.calculate(graph, symbolId);
-      const payload = masking.mask(JSON.stringify({
+      let symbols = result.impactedSymbols;
+      if (parsed.data.confidence) {
+        symbols = symbols.filter((s) => s.confidence === parsed.data.confidence);
+      }
+      symbols = filterByIntent(symbols, parsed.data.intent);
+      const confirmedCount = symbols.filter((s) => s.confidence === "confirmed").length;
+      const likelyCount = symbols.filter((s) => s.confidence === "likely").length;
+      const potentialCount = symbols.filter((s) => s.confidence === "potential").length;
+      const payload = masking.mask(JSON.stringify(wrapResponse({
         symbolId,
-        impactScore: result.impactedSymbols.length,
+        impactScore: symbols.length,
         directDependentsCount: result.directDependentsCount,
+        confirmedCount,
+        likelyCount,
+        potentialCount,
         overallRiskScore: result.overallRiskScore,
-        impactedSymbols: result.impactedSymbols
-      }));
+        impactedSymbols: symbols
+      })));
       const content = [];
       if (staleness) {
         const warning = staleness.check(storage.listIndexedFiles());
@@ -688,17 +909,1228 @@ function handleGetArchitecturalOverlay(storage, masking, staleness) {
   };
 }
 
+// src/adapters/mcp/get-dead-code.ts
+import { z as z6 } from "zod";
+
+// src/core/dead-code/dead-code-detector.ts
+var TEST_PATTERNS = [/__tests__/, /\.test\.ts$/, /\.spec\.ts$/, /\btests\//, /\bfixtures?\//];
+var CONFIG_PATTERNS = [/\.(config|rc)\.(ts|js|json)$/, /tsconfig/, /eslint/, /\.d\.ts$/];
+var FRAMEWORK_PATTERNS = [
+  // Vitest
+  /^(describe|it|expect|beforeAll|beforeEach|afterAll|afterEach|vi)$/,
+  // MCP SDK
+  /^(registerTool|registerPrompt|connect|close)$/,
+  // Zod schemas (conventionally exported for validation)
+  /Schema$/,
+  // Node.js lifecycle
+  /^main$/
+];
+var SCAFFOLDING_PATTERNS = [
+  { regex: /\bTODO\b/i, pattern: "TODO" },
+  { regex: /\bFIXME\b/i, pattern: "FIXME" },
+  { regex: /\bHACK\b/i, pattern: "HACK" },
+  { regex: /\bPLACEHOLDER\b/i, pattern: "PLACEHOLDER" },
+  { regex: /\bXXX\b/, pattern: "XXX" },
+  { regex: /Phase\s+\d|Step\s+\d/i, pattern: "PHASE/STEP" },
+  { regex: /not\s+(?:yet\s+)?implement/i, pattern: "NOT_IMPLEMENTED" },
+  { regex: /temporary|temp\s+fix/i, pattern: "TEMPORARY" }
+];
+var DeadCodeDetector = class {
+  detect(graph, options = {}) {
+    const allNodes = graph.allNodes();
+    const candidates = options.includeTests ? allNodes : allNodes.filter((n) => {
+      const file = n.symbolId.split("::")[0] ?? "";
+      return !this.matchesAny(file, TEST_PATTERNS) && !this.matchesAny(file, CONFIG_PATTERNS);
+    });
+    if (candidates.length === 0) {
+      return { totalSymbols: 0, reachableSymbols: 0, deadSymbols: [], unusedExports: [], deadFiles: [], scaffolding: this.detectScaffolding(options.sourceContents), deadCodePercentage: 0 };
+    }
+    const candidateIds = new Set(candidates.map((n) => n.symbolId));
+    const entryPoints = /* @__PURE__ */ new Set();
+    for (const node of candidates) {
+      if (this.isFrameworkSymbol(node.name)) {
+        entryPoints.add(node.symbolId);
+        continue;
+      }
+      const reverseEdges = graph.getReverseEdges(node.symbolId);
+      const forwardEdges = graph.getForwardEdges(node.symbolId);
+      const incomingFromCandidates = reverseEdges.filter((e) => candidateIds.has(e.from) && e.from !== node.symbolId);
+      if (incomingFromCandidates.length === 0) {
+        const hasOutgoing = forwardEdges.some((e) => candidateIds.has(e.to));
+        if (hasOutgoing || reverseEdges.length > 0) {
+          entryPoints.add(node.symbolId);
+        }
+      }
+    }
+    const reachable = /* @__PURE__ */ new Set();
+    const queue = [...entryPoints];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (reachable.has(current)) continue;
+      reachable.add(current);
+      for (const edge of graph.getForwardEdges(current)) {
+        if (!reachable.has(edge.to) && candidateIds.has(edge.to)) {
+          queue.push(edge.to);
+        }
+      }
+    }
+    const deadIds = /* @__PURE__ */ new Set();
+    for (const node of candidates) {
+      if (!reachable.has(node.symbolId)) {
+        deadIds.add(node.symbolId);
+      }
+    }
+    const cascadeDepthMap = this.computeCascadeDepths(graph, deadIds, candidateIds);
+    const deadSymbols = [];
+    for (const node of candidates) {
+      if (!deadIds.has(node.symbolId)) continue;
+      const file = node.symbolId.split("::")[0] ?? "";
+      const confidence = this.computeConfidence(graph, node.symbolId, deadIds);
+      const cascadeDepth = cascadeDepthMap.get(node.symbolId);
+      deadSymbols.push({
+        symbolId: node.symbolId,
+        file,
+        name: node.name,
+        kind: node.kind,
+        confidence,
+        reason: this.describeReason(confidence),
+        ...cascadeDepth !== void 0 && cascadeDepth > 0 ? { cascadeDepth } : {}
+      });
+    }
+    const fileStats = /* @__PURE__ */ new Map();
+    for (const node of candidates) {
+      const file = node.symbolId.split("::")[0] ?? "";
+      const stats = fileStats.get(file) ?? { total: 0, dead: 0 };
+      stats.total++;
+      if (deadIds.has(node.symbolId)) stats.dead++;
+      fileStats.set(file, stats);
+    }
+    const deadFiles = [...fileStats.entries()].filter(([, s]) => s.total > 0 && s.dead === s.total).map(([file]) => file);
+    const unusedExports = [];
+    for (const node of candidates) {
+      const reverseEdges = graph.getReverseEdges(node.symbolId);
+      const externalImporters = reverseEdges.filter(
+        (e) => candidateIds.has(e.from) && e.from !== node.symbolId
+      );
+      if (externalImporters.length === 0 && !deadIds.has(node.symbolId)) {
+        unusedExports.push({
+          symbolId: node.symbolId,
+          file: node.symbolId.split("::")[0] ?? "",
+          name: node.name,
+          kind: node.kind
+        });
+      }
+    }
+    const scaffolding = this.detectScaffolding(options.sourceContents);
+    const deadCodePercentage = Math.round(deadSymbols.length / candidates.length * 100 * 10) / 10;
+    return {
+      totalSymbols: candidates.length,
+      reachableSymbols: reachable.size,
+      deadSymbols,
+      unusedExports,
+      deadFiles,
+      scaffolding,
+      deadCodePercentage
+    };
+  }
+  computeConfidence(graph, symbolId, deadIds) {
+    const reverseEdges = graph.getReverseEdges(symbolId);
+    if (reverseEdges.length === 0) {
+      return 1;
+    }
+    const allImportersExcluded = reverseEdges.every((e) => {
+      const importerFile = e.from.split("::")[0] ?? "";
+      return this.matchesAny(importerFile, TEST_PATTERNS) || this.matchesAny(importerFile, CONFIG_PATTERNS);
+    });
+    if (allImportersExcluded) {
+      return 0.9;
+    }
+    const allImportersDead = reverseEdges.every((e) => deadIds.has(e.from));
+    if (allImportersDead) {
+      return 0.7;
+    }
+    return 0.7;
+  }
+  describeReason(confidence) {
+    switch (confidence) {
+      case 1:
+        return "Zero importers \u2014 no code references this symbol";
+      case 0.9:
+        return "Only referenced from test/config files";
+      case 0.7:
+        return "All importers are themselves dead (cascading)";
+    }
+  }
+  isFrameworkSymbol(name) {
+    return FRAMEWORK_PATTERNS.some((p) => p.test(name));
+  }
+  computeCascadeDepths(graph, deadIds, candidateIds) {
+    const depths = /* @__PURE__ */ new Map();
+    const rootDead = /* @__PURE__ */ new Set();
+    for (const id of deadIds) {
+      const reverseEdges = graph.getReverseEdges(id);
+      const deadImporters = reverseEdges.filter((e) => deadIds.has(e.from) && e.from !== id);
+      if (deadImporters.length === 0) {
+        rootDead.add(id);
+        depths.set(id, 0);
+      }
+    }
+    const queue = [...rootDead].map((id) => ({ id, depth: 0 }));
+    const visited = new Set(rootDead);
+    while (queue.length > 0) {
+      const current = queue.shift();
+      for (const edge of graph.getForwardEdges(current.id)) {
+        if (deadIds.has(edge.to) && !visited.has(edge.to) && candidateIds.has(edge.to)) {
+          const newDepth = current.depth + 1;
+          depths.set(edge.to, newDepth);
+          visited.add(edge.to);
+          queue.push({ id: edge.to, depth: newDepth });
+        }
+      }
+    }
+    return depths;
+  }
+  detectScaffolding(sourceContents) {
+    if (!sourceContents || sourceContents.size === 0) return [];
+    const results = [];
+    for (const [file, content] of sourceContents) {
+      if (this.matchesAny(file, TEST_PATTERNS) || this.matchesAny(file, CONFIG_PATTERNS)) continue;
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const { regex, pattern } of SCAFFOLDING_PATTERNS) {
+          if (regex.test(line)) {
+            results.push({
+              file,
+              line: i + 1,
+              pattern,
+              text: line.trim().slice(0, 120)
+            });
+            break;
+          }
+        }
+      }
+    }
+    return results;
+  }
+  matchesAny(value, patterns) {
+    return patterns.some((p) => p.test(value));
+  }
+};
+
+// src/adapters/mcp/get-dead-code.ts
+var InputSchema6 = z6.object({
+  includeTests: z6.boolean().optional().default(false),
+  intent: z6.string().optional().describe('Filter dead code results by intent keywords (e.g., "adapter", "core", "function")')
+});
+function handleFindDeadCode(storage, masking, staleness, ctxoRoot = ".ctxo") {
+  const detector = new DeadCodeDetector();
+  const getGraph = () => {
+    const jsonGraph = buildGraphFromJsonIndex(ctxoRoot);
+    if (jsonGraph.nodeCount > 0) return jsonGraph;
+    return buildGraphFromStorage(storage);
+  };
+  return (args) => {
+    try {
+      const parsed = InputSchema6.safeParse(args);
+      if (!parsed.success) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
+        };
+      }
+      const graph = 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(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-context-for-task.ts
+import { z as z7 } from "zod";
+
+// src/core/context-assembly/task-context-strategy.ts
+var TASK_WEIGHTS = {
+  fix: {
+    directDependency: 0.3,
+    interfaceTypeDef: 0.1,
+    blastRadiusDependent: 0.1,
+    highComplexity: 0.2,
+    antiPatternHistory: 0.3
+  },
+  extend: {
+    directDependency: 0.4,
+    interfaceTypeDef: 0.5,
+    blastRadiusDependent: 0.1,
+    highComplexity: 0,
+    antiPatternHistory: 0
+  },
+  refactor: {
+    directDependency: 0.2,
+    interfaceTypeDef: 0.1,
+    blastRadiusDependent: 0.5,
+    highComplexity: 0.1,
+    antiPatternHistory: 0.1
+  },
+  understand: {
+    directDependency: 0.5,
+    interfaceTypeDef: 0.3,
+    blastRadiusDependent: 0.1,
+    highComplexity: 0.1,
+    antiPatternHistory: 0
+  }
+};
+function getWeightsForTask(taskType) {
+  return TASK_WEIGHTS[taskType];
+}
+
+// src/core/context-assembly/context-assembler.ts
+var DEFAULT_TOKEN_BUDGET = 4e3;
+var ContextAssembler = class {
+  logicSlice = new LogicSliceQuery();
+  blastRadius = new BlastRadiusCalculator();
+  assembleForTask(graph, symbolId, taskType, indices, tokenBudget = DEFAULT_TOKEN_BUDGET) {
+    const target = graph.getNode(symbolId);
+    if (!target) return void 0;
+    const weights = getWeightsForTask(taskType);
+    const slice = this.logicSlice.getLogicSlice(graph, symbolId);
+    const blastResult = this.blastRadius.calculate(graph, symbolId);
+    const candidateMap = /* @__PURE__ */ new Map();
+    if (slice) {
+      for (const dep of slice.dependencies) {
+        candidateMap.set(dep.symbolId, {
+          node: dep,
+          signals: { isDirectDep: true, isInterfaceOrType: this.isInterfaceOrType(dep.kind), isDependent: false, complexity: 0, hasAntiPattern: false }
+        });
+      }
+    }
+    for (const entry of blastResult.impactedSymbols) {
+      const node = graph.getNode(entry.symbolId);
+      if (!node) continue;
+      const existing = candidateMap.get(entry.symbolId);
+      if (existing) {
+        existing.signals.isDependent = true;
+      } else {
+        candidateMap.set(entry.symbolId, {
+          node,
+          signals: { isDirectDep: false, isInterfaceOrType: this.isInterfaceOrType(node.kind), isDependent: true, complexity: 0, hasAntiPattern: false }
+        });
+      }
+    }
+    const fileIndexMap = new Map(indices.map((i) => [i.file, i]));
+    for (const [sid, candidate] of candidateMap) {
+      const file = sid.split("::")[0] ?? "";
+      const fileIndex = fileIndexMap.get(file);
+      if (fileIndex) {
+        const complexity = fileIndex.complexity?.find((c) => c.symbolId === sid);
+        candidate.signals.complexity = complexity?.cyclomatic ?? 0;
+        candidate.signals.hasAntiPattern = fileIndex.antiPatterns.length > 0;
+      }
+    }
+    const scored = [...candidateMap.entries()].map(([, { node, signals }]) => ({
+      entry: this.buildContextEntry(node, signals, weights),
+      score: this.computeScore(signals, weights)
+    }));
+    scored.sort((a, b) => b.score - a.score);
+    const context = [];
+    let totalTokens = 0;
+    for (const { entry } of scored) {
+      if (totalTokens + entry.tokens > tokenBudget) continue;
+      context.push(entry);
+      totalTokens += entry.tokens;
+    }
+    const warnings = [];
+    const targetFile = symbolId.split("::")[0] ?? "";
+    const targetIndex = fileIndexMap.get(targetFile);
+    if (targetIndex && targetIndex.antiPatterns.length > 0) {
+      warnings.push(`\u26A0 Target symbol has ${targetIndex.antiPatterns.length} anti-pattern(s) in file history`);
+    }
+    return { target, taskType, context, totalTokens, tokenBudget, warnings };
+  }
+  assembleRanked(graph, query, strategy = "combined", tokenBudget = DEFAULT_TOKEN_BUDGET) {
+    const allNodes = graph.allNodes();
+    const queryLower = query.toLowerCase();
+    let maxReverseEdges = 1;
+    for (const node of allNodes) {
+      const count = graph.getReverseEdges(node.symbolId).length;
+      if (count > maxReverseEdges) maxReverseEdges = count;
+    }
+    const scored = allNodes.map((node) => {
+      const relevanceScore = this.computeTextRelevance(node.name, queryLower);
+      const importanceScore = graph.getReverseEdges(node.symbolId).length / maxReverseEdges;
+      let combinedScore;
+      switch (strategy) {
+        case "dependency":
+          combinedScore = relevanceScore;
+          break;
+        case "importance":
+          combinedScore = importanceScore;
+          break;
+        default:
+          combinedScore = relevanceScore * 0.6 + importanceScore * 0.4;
+      }
+      return {
+        symbolId: node.symbolId,
+        name: node.name,
+        kind: node.kind,
+        file: node.symbolId.split("::")[0] ?? "",
+        relevanceScore: Math.round(relevanceScore * 1e3) / 1e3,
+        importanceScore: Math.round(importanceScore * 1e3) / 1e3,
+        combinedScore: Math.round(combinedScore * 1e3) / 1e3,
+        tokens: this.estimateTokens(node)
+      };
+    });
+    const filtered = strategy === "importance" ? scored : scored.filter((s) => s.relevanceScore > 0 || s.importanceScore > 0.1);
+    filtered.sort((a, b) => b.combinedScore - a.combinedScore);
+    const results = [];
+    let totalTokens = 0;
+    for (const item of filtered) {
+      if (totalTokens + item.tokens > tokenBudget) continue;
+      results.push(item);
+      totalTokens += item.tokens;
+    }
+    return { query, strategy, results, totalTokens, tokenBudget };
+  }
+  computeTextRelevance(name, queryLower) {
+    const nameLower = name.toLowerCase();
+    if (nameLower === queryLower) return 1;
+    if (nameLower.includes(queryLower)) return 0.7;
+    if (queryLower.split(/\s+/).some((word) => nameLower.includes(word))) return 0.4;
+    return 0;
+  }
+  computeScore(signals, weights) {
+    let score = 0;
+    if (signals.isDirectDep) score += weights.directDependency;
+    if (signals.isInterfaceOrType) score += weights.interfaceTypeDef;
+    if (signals.isDependent) score += weights.blastRadiusDependent;
+    if (signals.complexity > 5) score += weights.highComplexity;
+    if (signals.hasAntiPattern) score += weights.antiPatternHistory;
+    return Math.round(score * 1e3) / 1e3;
+  }
+  buildContextEntry(node, signals, weights) {
+    const reasons = [];
+    if (signals.isDirectDep) reasons.push("direct dependency");
+    if (signals.isInterfaceOrType) reasons.push("type/interface definition");
+    if (signals.isDependent) reasons.push("blast radius dependent");
+    if (signals.complexity > 5) reasons.push(`high complexity (CC=${signals.complexity})`);
+    if (signals.hasAntiPattern) reasons.push("anti-pattern history");
+    return {
+      symbolId: node.symbolId,
+      name: node.name,
+      kind: node.kind,
+      file: node.symbolId.split("::")[0] ?? "",
+      relevanceScore: this.computeScore(signals, weights),
+      reason: reasons.join(", ") || "related symbol",
+      lines: node.endLine - node.startLine + 1,
+      tokens: this.estimateTokens(node)
+    };
+  }
+  isInterfaceOrType(kind) {
+    return kind === "interface" || kind === "type";
+  }
+  estimateTokens(node) {
+    if (node.startOffset !== void 0 && node.endOffset !== void 0) {
+      return Math.ceil((node.endOffset - node.startOffset) / 4);
+    }
+    return (node.endLine - node.startLine + 1) * 10;
+  }
+};
+
+// src/adapters/mcp/get-context-for-task.ts
+var TaskTypeSchema = z7.enum(["fix", "extend", "refactor", "understand"]);
+var InputSchema7 = z7.object({
+  symbolId: z7.string().min(1),
+  taskType: TaskTypeSchema,
+  tokenBudget: z7.number().min(100).optional().default(4e3)
+});
+function handleGetContextForTask(storage, masking, staleness, ctxoRoot = ".ctxo") {
+  const assembler = new ContextAssembler();
+  const indexReader = new JsonIndexReader(ctxoRoot);
+  const getGraph = () => {
+    const jsonGraph = buildGraphFromJsonIndex(ctxoRoot);
+    if (jsonGraph.nodeCount > 0) return jsonGraph;
+    return buildGraphFromStorage(storage);
+  };
+  return (args) => {
+    try {
+      const parsed = InputSchema7.safeParse(args);
+      if (!parsed.success) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
+        };
+      }
+      const { symbolId, taskType, tokenBudget } = parsed.data;
+      const graph = getGraph();
+      const indices = indexReader.readAll();
+      const result = assembler.assembleForTask(graph, symbolId, taskType, indices, tokenBudget);
+      if (!result) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ found: false, hint: 'Symbol not found. Run "ctxo index".' }) }]
+        };
+      }
+      const payload = masking.mask(JSON.stringify(wrapResponse(result)));
+      const content = [];
+      if (staleness) {
+        const warning = staleness.check(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-ranked-context.ts
+import { z as z8 } from "zod";
+var InputSchema8 = z8.object({
+  query: z8.string().min(1),
+  tokenBudget: z8.number().min(100).optional().default(4e3),
+  strategy: z8.enum(["combined", "dependency", "importance"]).optional().default("combined")
+});
+function handleGetRankedContext(storage, masking, staleness, ctxoRoot = ".ctxo") {
+  const assembler = new ContextAssembler();
+  const getGraph = () => {
+    const jsonGraph = buildGraphFromJsonIndex(ctxoRoot);
+    if (jsonGraph.nodeCount > 0) return jsonGraph;
+    return buildGraphFromStorage(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 { query, tokenBudget, strategy } = parsed.data;
+      const graph = getGraph();
+      const result = assembler.assembleRanked(graph, query, strategy, tokenBudget);
+      const payload = masking.mask(JSON.stringify(wrapResponse(result)));
+      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/search-symbols.ts
+import { z as z9 } from "zod";
+var InputSchema9 = z9.object({
+  pattern: z9.string().min(1),
+  kind: z9.enum(["function", "class", "interface", "method", "variable", "type"]).optional(),
+  filePattern: z9.string().optional(),
+  limit: z9.number().int().min(1).max(100).optional().default(25)
+});
+function handleSearchSymbols(storage, masking, staleness, ctxoRoot = ".ctxo") {
+  const getGraph = () => {
+    const jsonGraph = buildGraphFromJsonIndex(ctxoRoot);
+    if (jsonGraph.nodeCount > 0) return jsonGraph;
+    return buildGraphFromStorage(storage);
+  };
+  return (args) => {
+    try {
+      const parsed = InputSchema9.safeParse(args);
+      if (!parsed.success) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
+        };
+      }
+      const { pattern, kind, filePattern, limit } = parsed.data;
+      const graph = getGraph();
+      const allNodes = graph.allNodes();
+      let matcher;
+      try {
+        const regex = new RegExp(pattern, "i");
+        matcher = (name) => regex.test(name);
+      } catch {
+        const lowerPattern = pattern.toLowerCase();
+        matcher = (name) => name.toLowerCase().includes(lowerPattern);
+      }
+      const matches = allNodes.filter((node) => {
+        if (!matcher(node.name)) return false;
+        if (kind && node.kind !== kind) return false;
+        if (filePattern) {
+          const file = node.symbolId.split("::")[0] ?? "";
+          if (!file.toLowerCase().includes(filePattern.toLowerCase())) return false;
+        }
+        return true;
+      });
+      const results = matches.slice(0, limit).map((node) => ({
+        symbolId: node.symbolId,
+        name: node.name,
+        kind: node.kind,
+        file: node.symbolId.split("::")[0],
+        startLine: node.startLine,
+        endLine: node.endLine
+      }));
+      const payload = masking.mask(JSON.stringify(wrapResponse({
+        totalMatches: matches.length,
+        results
+      })));
+      const content = [];
+      if (staleness) {
+        const warning = staleness.check(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-changed-symbols.ts
+import { z as z10 } from "zod";
+var InputSchema10 = z10.object({
+  since: z10.string().optional().default("HEAD~1"),
+  maxFiles: z10.number().int().min(1).optional().default(50)
+});
+function handleGetChangedSymbols(storage, git, masking, staleness, ctxoRoot = ".ctxo") {
+  const getGraph = () => {
+    const jsonGraph = buildGraphFromJsonIndex(ctxoRoot);
+    if (jsonGraph.nodeCount > 0) return jsonGraph;
+    return buildGraphFromStorage(storage);
+  };
+  return async (args) => {
+    try {
+      const parsed = InputSchema10.safeParse(args);
+      if (!parsed.success) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
+        };
+      }
+      const { since, maxFiles } = parsed.data;
+      const changedPaths = await git.getChangedFiles(since);
+      const graph = 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(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/find-importers.ts
+import { z as z11 } from "zod";
+var InputSchema11 = z11.object({
+  symbolId: z11.string().min(1),
+  edgeKinds: z11.array(z11.enum(["imports", "calls", "extends", "implements", "uses"])).optional(),
+  transitive: z11.boolean().optional().default(false),
+  maxDepth: z11.number().int().min(1).max(10).optional().default(5),
+  intent: z11.string().optional().describe('Filter results by intent keywords (e.g., "test", "adapter", "core")')
+});
+function handleFindImporters(storage, masking, staleness, ctxoRoot = ".ctxo") {
+  const getGraph = () => {
+    const jsonGraph = buildGraphFromJsonIndex(ctxoRoot);
+    if (jsonGraph.nodeCount > 0) return jsonGraph;
+    return buildGraphFromStorage(storage);
+  };
+  return (args) => {
+    try {
+      const parsed = InputSchema11.safeParse(args);
+      if (!parsed.success) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
+        };
+      }
+      const { symbolId, edgeKinds, transitive, maxDepth } = parsed.data;
+      const graph = getGraph();
+      if (!graph.hasNode(symbolId)) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ found: false, hint: 'Symbol not found. Run "ctxo index" to build the codebase index.' }) }]
+        };
+      }
+      const importers = [];
+      if (!transitive) {
+        const reverseEdges = graph.getReverseEdges(symbolId);
+        const seen = /* @__PURE__ */ new Map();
+        for (const edge of reverseEdges) {
+          if (edgeKinds && !edgeKinds.includes(edge.kind)) continue;
+          const node = graph.getNode(edge.from);
+          if (node) {
+            const existing = seen.get(node.symbolId);
+            if (existing) {
+              if (!existing.edgeKinds.includes(edge.kind)) {
+                existing.edgeKinds.push(edge.kind);
+              }
+            } else {
+              const entry = {
+                symbolId: node.symbolId,
+                name: node.name,
+                kind: node.kind,
+                file: node.symbolId.split("::")[0] ?? "",
+                edgeKind: edge.kind,
+                depth: 1
+              };
+              seen.set(node.symbolId, { node: entry, edgeKinds: [edge.kind] });
+              importers.push(entry);
+            }
+          }
+        }
+      } else {
+        const visited = /* @__PURE__ */ new Set([symbolId]);
+        const queue = [{ id: symbolId, depth: 0 }];
+        while (queue.length > 0) {
+          const current = queue.shift();
+          if (current.depth >= maxDepth) continue;
+          const reverseEdges = graph.getReverseEdges(current.id);
+          for (const edge of reverseEdges) {
+            if (edgeKinds && !edgeKinds.includes(edge.kind)) continue;
+            if (visited.has(edge.from)) continue;
+            visited.add(edge.from);
+            const node = graph.getNode(edge.from);
+            if (node) {
+              const depth = current.depth + 1;
+              importers.push({
+                symbolId: node.symbolId,
+                name: node.name,
+                kind: node.kind,
+                file: node.symbolId.split("::")[0] ?? "",
+                edgeKind: edge.kind,
+                depth
+              });
+              queue.push({ id: edge.from, depth });
+            }
+          }
+        }
+      }
+      importers.sort((a, b) => a.depth - b.depth);
+      const filtered = filterByIntent(importers, parsed.data.intent);
+      const payload = masking.mask(JSON.stringify(wrapResponse({
+        symbolId,
+        importerCount: filtered.length,
+        importers: filtered
+      })));
+      const content = [];
+      if (staleness) {
+        const warning = staleness.check(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-class-hierarchy.ts
+import { z as z12 } from "zod";
+var InputSchema12 = z12.object({
+  symbolId: z12.string().min(1).optional(),
+  direction: z12.enum(["ancestors", "descendants", "both"]).optional().default("both")
+});
+function handleGetClassHierarchy(storage, masking, staleness, ctxoRoot = ".ctxo") {
+  const getGraph = () => {
+    const jsonGraph = buildGraphFromJsonIndex(ctxoRoot);
+    if (jsonGraph.nodeCount > 0) return jsonGraph;
+    return buildGraphFromStorage(storage);
+  };
+  return (args) => {
+    try {
+      const parsed = InputSchema12.safeParse(args);
+      if (!parsed.success) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
+        };
+      }
+      const { symbolId, direction } = parsed.data;
+      const graph = getGraph();
+      if (symbolId) {
+        return handleRooted(graph, symbolId, direction, masking, staleness, storage);
+      }
+      return handleFull(graph, masking, staleness, storage);
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
+      };
+    }
+  };
+  function handleRooted(graph, symbolId, direction, maskingPort, stalenessCheck, storagePort) {
+    if (!graph.hasNode(symbolId)) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ found: false, hint: 'Symbol not found. Run "ctxo index" to build the codebase index.' }) }]
+      };
+    }
+    const ancestors = [];
+    const descendants = [];
+    const isHierarchyEdge = (kind) => kind === "extends" || kind === "implements";
+    if (direction === "ancestors" || direction === "both") {
+      const visited = /* @__PURE__ */ new Set([symbolId]);
+      const queue = [{ id: symbolId, depth: 0 }];
+      while (queue.length > 0) {
+        const current = queue.shift();
+        for (const edge of graph.getForwardEdges(current.id)) {
+          if (!isHierarchyEdge(edge.kind)) continue;
+          if (visited.has(edge.to)) continue;
+          visited.add(edge.to);
+          const node = graph.getNode(edge.to);
+          if (node) {
+            const depth = current.depth + 1;
+            ancestors.push({
+              symbolId: node.symbolId,
+              name: node.name,
+              kind: node.kind,
+              file: node.symbolId.split("::")[0] ?? "",
+              edgeKind: edge.kind,
+              depth
+            });
+            queue.push({ id: edge.to, depth });
+          }
+        }
+      }
+    }
+    if (direction === "descendants" || direction === "both") {
+      const visited = /* @__PURE__ */ new Set([symbolId]);
+      const queue = [{ id: symbolId, depth: 0 }];
+      while (queue.length > 0) {
+        const current = queue.shift();
+        for (const edge of graph.getReverseEdges(current.id)) {
+          if (!isHierarchyEdge(edge.kind)) continue;
+          if (visited.has(edge.from)) continue;
+          visited.add(edge.from);
+          const node = graph.getNode(edge.from);
+          if (node) {
+            const depth = current.depth + 1;
+            descendants.push({
+              symbolId: node.symbolId,
+              name: node.name,
+              kind: node.kind,
+              file: node.symbolId.split("::")[0] ?? "",
+              edgeKind: edge.kind,
+              depth
+            });
+            queue.push({ id: edge.from, depth });
+          }
+        }
+      }
+    }
+    const result = { symbolId };
+    if (direction === "ancestors" || direction === "both") result.ancestors = ancestors;
+    if (direction === "descendants" || direction === "both") result.descendants = descendants;
+    const payload = maskingPort.mask(JSON.stringify(wrapResponse(result)));
+    const content = [];
+    if (stalenessCheck) {
+      const warning = stalenessCheck.check(storagePort.listIndexedFiles());
+      if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
+    }
+    content.push({ type: "text", text: payload });
+    return { content };
+  }
+  function handleFull(graph, maskingPort, stalenessCheck, storagePort) {
+    const isHierarchyEdge = (kind) => kind === "extends" || kind === "implements";
+    const hierarchyEdges = graph.allEdges().filter((e) => isHierarchyEdge(e.kind));
+    const involved = /* @__PURE__ */ new Set();
+    for (const edge of hierarchyEdges) {
+      involved.add(edge.from);
+      involved.add(edge.to);
+    }
+    const sources = new Set(hierarchyEdges.map((e) => e.from));
+    const roots = [...involved].filter((id) => !sources.has(id));
+    const rootSet = roots.length > 0 ? roots : [...involved];
+    function buildTree(rootId, visited2) {
+      const node = graph.getNode(rootId);
+      if (!node) return void 0;
+      visited2.add(rootId);
+      const children = [];
+      for (const edge of graph.getReverseEdges(rootId)) {
+        if (!isHierarchyEdge(edge.kind)) continue;
+        if (visited2.has(edge.from)) continue;
+        const child = buildTree(edge.from, visited2);
+        if (child) {
+          child.edgeKind = edge.kind;
+          children.push(child);
+        }
+      }
+      return {
+        symbolId: node.symbolId,
+        name: node.name,
+        kind: node.kind,
+        file: node.symbolId.split("::")[0] ?? "",
+        children
+      };
+    }
+    const visited = /* @__PURE__ */ new Set();
+    const hierarchies = [];
+    for (const rootId of rootSet) {
+      if (visited.has(rootId)) continue;
+      const tree = buildTree(rootId, visited);
+      if (tree) hierarchies.push(tree);
+    }
+    const payload = maskingPort.mask(JSON.stringify(wrapResponse({
+      hierarchies,
+      totalClasses: involved.size,
+      totalEdges: hierarchyEdges.length
+    })));
+    const content = [];
+    if (stalenessCheck) {
+      const warning = stalenessCheck.check(storagePort.listIndexedFiles());
+      if (warning) content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
+    }
+    content.push({ type: "text", text: payload });
+    return { content };
+  }
+}
+
+// src/adapters/mcp/get-symbol-importance.ts
+import { z as z13 } from "zod";
+
+// src/core/importance/pagerank-calculator.ts
+var DEFAULT_DAMPING = 0.85;
+var DEFAULT_MAX_ITERATIONS = 100;
+var DEFAULT_TOLERANCE = 1e-6;
+var DEFAULT_LIMIT = 25;
+var PageRankCalculator = class {
+  calculate(graph, options = {}) {
+    const damping = options.damping ?? DEFAULT_DAMPING;
+    const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+    const tolerance = options.tolerance ?? DEFAULT_TOLERANCE;
+    const limit = options.limit ?? DEFAULT_LIMIT;
+    const nodes = graph.allNodes();
+    const n = nodes.length;
+    if (n === 0) {
+      return { rankings: [], totalSymbols: 0, iterations: 0, converged: true };
+    }
+    const scores = /* @__PURE__ */ new Map();
+    const initialScore = 1 / n;
+    for (const node of nodes) {
+      scores.set(node.symbolId, initialScore);
+    }
+    const outDegree = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      outDegree.set(node.symbolId, graph.getForwardEdges(node.symbolId).length);
+    }
+    let iterations = 0;
+    let converged = false;
+    while (iterations < maxIterations) {
+      const newScores = /* @__PURE__ */ new Map();
+      const base = (1 - damping) / n;
+      let danglingSum = 0;
+      for (const node of nodes) {
+        if ((outDegree.get(node.symbolId) ?? 0) === 0) {
+          danglingSum += scores.get(node.symbolId) ?? 0;
+        }
+      }
+      const danglingContrib = damping * danglingSum / n;
+      for (const node of nodes) {
+        let incomingScore = 0;
+        const reverseEdges = graph.getReverseEdges(node.symbolId);
+        const contributors = /* @__PURE__ */ new Set();
+        for (const edge of reverseEdges) {
+          if (contributors.has(edge.from)) continue;
+          contributors.add(edge.from);
+          const fromScore = scores.get(edge.from) ?? 0;
+          const fromOut = outDegree.get(edge.from) ?? 1;
+          incomingScore += fromScore / fromOut;
+        }
+        newScores.set(node.symbolId, base + damping * incomingScore + danglingContrib);
+      }
+      let maxDelta = 0;
+      for (const node of nodes) {
+        const delta = Math.abs((newScores.get(node.symbolId) ?? 0) - (scores.get(node.symbolId) ?? 0));
+        if (delta > maxDelta) maxDelta = delta;
+      }
+      for (const [id, score] of newScores) {
+        scores.set(id, score);
+      }
+      iterations++;
+      if (maxDelta < tolerance) {
+        converged = true;
+        break;
+      }
+    }
+    const entries = nodes.map((node) => ({
+      symbolId: node.symbolId,
+      name: node.name,
+      kind: node.kind,
+      file: node.symbolId.split("::")[0] ?? "",
+      score: Math.round((scores.get(node.symbolId) ?? 0) * 1e6) / 1e6,
+      inDegree: graph.getReverseEdges(node.symbolId).length,
+      outDegree: outDegree.get(node.symbolId) ?? 0
+    }));
+    entries.sort((a, b) => b.score - a.score);
+    return {
+      rankings: entries.slice(0, limit),
+      totalSymbols: n,
+      iterations,
+      converged
+    };
+  }
+};
+
+// src/adapters/mcp/get-symbol-importance.ts
+var InputSchema13 = z13.object({
+  limit: z13.number().int().min(1).max(200).optional().default(25),
+  kind: z13.enum(["function", "class", "interface", "method", "variable", "type"]).optional(),
+  filePattern: z13.string().optional(),
+  damping: z13.number().min(0).max(1).optional().default(0.85)
+});
+function handleGetSymbolImportance(storage, masking, staleness, ctxoRoot = ".ctxo") {
+  const calculator = new PageRankCalculator();
+  const getGraph = () => {
+    const jsonGraph = buildGraphFromJsonIndex(ctxoRoot);
+    if (jsonGraph.nodeCount > 0) return jsonGraph;
+    return buildGraphFromStorage(storage);
+  };
+  return (args) => {
+    try {
+      const parsed = InputSchema13.safeParse(args);
+      if (!parsed.success) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
+        };
+      }
+      const { limit, kind, filePattern, damping } = parsed.data;
+      const graph = 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(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-pr-impact.ts
+import { z as z14 } from "zod";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+var InputSchema14 = z14.object({
+  since: z14.string().optional().default("HEAD~1"),
+  maxFiles: z14.number().int().min(1).optional().default(50),
+  confidence: z14.enum(["confirmed", "likely", "potential"]).optional()
+});
+function loadCoChanges(ctxoRoot) {
+  const path = join(ctxoRoot, "index", "co-changes.json");
+  if (!existsSync(path)) return void 0;
+  try {
+    const matrix = JSON.parse(readFileSync(path, "utf-8"));
+    return loadCoChangeMap(matrix);
+  } catch {
+    return void 0;
+  }
+}
+function handleGetPrImpact(storage, git, masking, staleness, ctxoRoot = ".ctxo") {
+  const calculator = new BlastRadiusCalculator();
+  const getGraph = () => {
+    const jsonGraph = buildGraphFromJsonIndex(ctxoRoot);
+    if (jsonGraph.nodeCount > 0) return jsonGraph;
+    return buildGraphFromStorage(storage);
+  };
+  return async (args) => {
+    try {
+      const parsed = InputSchema14.safeParse(args);
+      if (!parsed.success) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
+        };
+      }
+      const { since, maxFiles, confidence: confFilter } = parsed.data;
+      const changedPaths = await git.getChangedFiles(since);
+      if (changedPaths.length === 0) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ since, changedFiles: 0, changedSymbols: 0, totalImpact: 0, riskLevel: "low", files: [], summary: { confirmedTotal: 0, likelyTotal: 0, potentialTotal: 0, highRiskSymbols: [] } }) }]
+        };
+      }
+      const graph = getGraph();
+      const coChangeMap = loadCoChanges(ctxoRoot);
+      const allNodes = graph.allNodes();
+      const nodesByFile = /* @__PURE__ */ new Map();
+      for (const node of allNodes) {
+        const file = node.symbolId.split("::")[0];
+        let list = nodesByFile.get(file);
+        if (!list) {
+          list = [];
+          nodesByFile.set(file, list);
+        }
+        list.push(node);
+      }
+      const limitedPaths = changedPaths.slice(0, maxFiles);
+      let totalImpact = 0;
+      let confirmedTotal = 0;
+      let likelyTotal = 0;
+      let potentialTotal = 0;
+      const highRiskSymbols = [];
+      const files = [];
+      for (const filePath of limitedPaths) {
+        const symbols = nodesByFile.get(filePath);
+        if (!symbols || symbols.length === 0) continue;
+        const fileSymbols = [];
+        for (const sym of symbols) {
+          const result = calculator.calculate(graph, sym.symbolId, coChangeMap);
+          let impacted = result.impactedSymbols;
+          if (confFilter) {
+            impacted = impacted.filter((s) => s.confidence === confFilter);
+          }
+          const impactScore = impacted.length;
+          const confirmed = impacted.filter((s) => s.confidence === "confirmed").length;
+          const likely = impacted.filter((s) => s.confidence === "likely").length;
+          const potential = impacted.filter((s) => s.confidence === "potential").length;
+          totalImpact += impactScore;
+          confirmedTotal += confirmed;
+          likelyTotal += likely;
+          potentialTotal += potential;
+          if (result.overallRiskScore > 0.7) {
+            highRiskSymbols.push(sym.symbolId);
+          }
+          const topImpacted = impacted.sort((a, b) => b.riskScore - a.riskScore).slice(0, 10);
+          fileSymbols.push({
+            symbolId: sym.symbolId,
+            name: sym.name,
+            kind: sym.kind,
+            blast: {
+              impactScore,
+              confirmedCount: confirmed,
+              likelyCount: likely,
+              potentialCount: potential,
+              riskScore: result.overallRiskScore,
+              topImpacted
+            }
+          });
+        }
+        let coChangedWith;
+        if (coChangeMap) {
+          const entries = coChangeMap.get(filePath);
+          if (entries && entries.length > 0) {
+            coChangedWith = entries.sort((a, b) => b.frequency - a.frequency).slice(0, 5).map((e) => e.file1 === filePath ? e.file2 : e.file1);
+          }
+        }
+        files.push({
+          file: filePath,
+          symbols: fileSymbols,
+          ...coChangedWith ? { coChangedWith } : {}
+        });
+      }
+      const maxRisk = files.reduce((max, f) => {
+        const fileMax = f.symbols.reduce((m, s) => Math.max(m, s.blast.riskScore), 0);
+        return Math.max(max, fileMax);
+      }, 0);
+      const riskLevel = maxRisk > 0.7 ? "high" : maxRisk > 0.3 ? "medium" : "low";
+      const changedSymbols = files.reduce((sum, f) => sum + f.symbols.length, 0);
+      const payload = masking.mask(JSON.stringify(wrapResponse({
+        since,
+        changedFiles: files.length,
+        changedSymbols,
+        totalImpact,
+        riskLevel,
+        files,
+        summary: {
+          confirmedTotal,
+          likelyTotal,
+          potentialTotal,
+          highRiskSymbols: highRiskSymbols.slice(0, 10)
+        }
+      })));
+      const content = [];
+      if (staleness) {
+        const warning = staleness.check(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/index.ts
+var log = createLogger("ctxo:mcp");
 function loadMaskingConfig(ctxoRoot) {
-  const jsonConfigPath = join(ctxoRoot, "masking.json");
-  if (existsSync(jsonConfigPath)) {
+  const jsonConfigPath = join2(ctxoRoot, "masking.json");
+  if (existsSync2(jsonConfigPath)) {
     try {
-      const raw = readFileSync(jsonConfigPath, "utf-8");
+      const raw = readFileSync2(jsonConfigPath, "utf-8");
       const patterns = JSON.parse(raw);
-      console.error(`[ctxo] Loaded ${patterns.length} custom masking pattern(s)`);
+      log.info(`Loaded ${patterns.length} custom masking pattern(s)`);
       return MaskingPipeline.fromConfig(patterns);
     } catch (err) {
-      console.error(`[ctxo] Failed to load masking config: ${err.message}`);
+      log.error(`Failed to load masking config: ${err.message}`);
     }
   }
   return new MaskingPipeline();
@@ -706,7 +2138,7 @@ function loadMaskingConfig(ctxoRoot) {
 async function main() {
   const args = process.argv.slice(2);
   if (args.length > 0) {
-    const { CliRouter } = await import("./cli-router-PIWHLS5F.js");
+    const { CliRouter } = await import("./cli-router-NRUGPICL.js");
     const router = new CliRouter(process.cwd());
     await router.route(args);
     return;
@@ -717,40 +2149,51 @@ async function main() {
   const masking = loadMaskingConfig(ctxoRoot);
   const git = new SimpleGitAdapter(process.cwd());
   const server = new McpServer({ name: "ctxo", version: "0.1.0" });
-  const { StalenessDetector } = await import("./staleness-detector-5AN223FM.js");
+  const { StalenessDetector } = await import("./staleness-detector-VSDPTPX7.js");
   const staleness = new StalenessDetector(process.cwd(), ctxoRoot);
+  const toolAnnotations = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  };
   const logicSliceHandler = handleGetLogicSlice(storage, masking, staleness, ctxoRoot);
   const whyContextHandler = handleGetWhyContext(storage, git, masking, staleness, ctxoRoot);
   const changeIntelligenceHandler = handleGetChangeIntelligence(storage, git, masking, staleness, ctxoRoot);
   server.registerTool(
     "get_logic_slice",
     {
-      description: "Retrieve a Logic-Slice for a named symbol \u2014 the symbol plus all transitive dependencies",
+      description: 'Retrieve a symbol and all its transitive dependencies as a Logic-Slice. Use this when you need to UNDERSTAND what a symbol depends on (downstream view). L1=signature only, L2=direct deps, L3=full closure, L4=with token budget. Use `intent` to filter dependencies by keyword (e.g., "core", "adapter"). All responses include `_meta` with item counts and truncation info. For impact analysis (what BREAKS if this changes), use get_blast_radius instead. For task-specific context, use get_context_for_task.',
       inputSchema: {
-        symbolId: z6.string().optional().describe("Single symbol ID (format: file::name::kind)"),
-        symbolIds: z6.array(z6.string()).optional().describe("Batch: array of symbol IDs"),
-        level: z6.number().min(1).max(4).optional().default(3).describe("Detail level (L1=signature, L2=direct deps, L3=full closure, L4=with token budget)")
-      }
+        symbolId: z15.string().optional().describe("Single symbol ID (format: file::name::kind)"),
+        symbolIds: z15.array(z15.string()).optional().describe("Batch: array of symbol IDs"),
+        level: z15.number().min(1).max(4).optional().default(3).describe("Detail level (L1=signature, L2=direct deps, L3=full closure, L4=with token budget)"),
+        intent: z15.string().optional().describe('Filter dependencies by intent keywords (e.g., "core", "adapter")')
+      },
+      annotations: toolAnnotations
     },
     (args2) => logicSliceHandler(args2)
   );
   server.registerTool(
     "get_why_context",
     {
-      description: "Retrieve git commit intent, anti-pattern warnings from revert history for a symbol",
+      description: "Retrieve git commit history intent and anti-pattern warnings (reverts, rollbacks) for a symbol. Use this when you need to understand WHY code was written this way or whether it has a history of problems. Pair with get_change_intelligence for complexity/churn scores.",
       inputSchema: {
-        symbolId: z6.string().min(1).describe("The symbol ID (format: file::name::kind)")
-      }
+        symbolId: z15.string().min(1).describe("The symbol ID (format: file::name::kind)"),
+        maxCommits: z15.number().int().min(1).optional().describe("Limit commit history to N most recent commits")
+      },
+      annotations: toolAnnotations
     },
     (args2) => whyContextHandler(args2)
   );
   server.registerTool(
     "get_change_intelligence",
     {
-      description: "Retrieve complexity x churn composite score for a symbol",
+      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: z6.string().min(1).describe("The symbol ID (format: file::name::kind)")
-      }
+        symbolId: z15.string().min(1).describe("The symbol ID (format: file::name::kind)")
+      },
+      annotations: toolAnnotations
     },
     (args2) => changeIntelligenceHandler(args2)
   );
@@ -758,10 +2201,13 @@ async function main() {
   server.registerTool(
     "get_blast_radius",
     {
-      description: "Retrieve the blast radius for a symbol \u2014 symbols that would break if it changed",
+      description: "BEFORE modifying any function or class, call this to understand impact. Returns all symbols that would break if the target changes, split into confirmed (direct importers), likely (co-changed), and potential (transitive) tiers with risk scores. Use `confidence` to filter by tier, `intent` to filter by keyword. Large results are auto-truncated with `_meta.hint` for drill-in. For what a symbol DEPENDS ON (downstream), use get_logic_slice instead. For full PR-level analysis, use get_pr_impact.",
       inputSchema: {
-        symbolId: z6.string().min(1).describe("The symbol ID (format: file::name::kind)")
-      }
+        symbolId: z15.string().min(1).describe("The symbol ID (format: file::name::kind)"),
+        confidence: z15.enum(["confirmed", "likely", "potential"]).optional().describe("Filter by confidence tier"),
+        intent: z15.string().optional().describe('Filter impacted symbols by intent keywords (e.g., "test", "adapter")')
+      },
+      annotations: toolAnnotations
     },
     (args2) => blastRadiusHandler(args2)
   );
@@ -769,18 +2215,149 @@ async function main() {
   server.registerTool(
     "get_architectural_overlay",
     {
-      description: "Retrieve an architectural overlay \u2014 layer map identifying Domain, Infrastructure, and Adapter boundaries",
+      description: "Get the project architectural layer map \u2014 identifies which symbols belong to Domain, Infrastructure, and Adapter layers. Use this when onboarding to a new codebase or validating that a change respects layer boundaries. For symbol-level analysis, use get_logic_slice or get_blast_radius.",
       inputSchema: {
-        layer: z6.string().optional().describe("Filter by specific layer name")
-      }
+        layer: z15.string().optional().describe("Filter by specific layer name")
+      },
+      annotations: toolAnnotations
     },
     (args2) => overlayHandler(args2)
   );
+  const deadCodeHandler = handleFindDeadCode(storage, masking, staleness, ctxoRoot);
+  server.registerTool(
+    "find_dead_code",
+    {
+      description: 'Find unreachable symbols and files that are never imported or called anywhere. Use this during cleanup, refactoring, or before deleting code to confirm it is truly unused. Use `intent` to filter results by keyword (e.g., "adapter", "function"). Large results are auto-truncated with `_meta`. For reverse dependency lookup of a specific symbol, use find_importers instead.',
+      inputSchema: {
+        includeTests: z15.boolean().optional().default(false).describe("Include test files in analysis (default: exclude)"),
+        intent: z15.string().optional().describe('Filter dead code results by intent keywords (e.g., "adapter", "function")')
+      },
+      annotations: toolAnnotations
+    },
+    (args2) => deadCodeHandler(args2)
+  );
+  const contextForTaskHandler = handleGetContextForTask(storage, masking, staleness, ctxoRoot);
+  server.registerTool(
+    "get_context_for_task",
+    {
+      description: 'Get task-optimized context for a symbol based on what you are about to do. Specify taskType: "fix" (bug investigation \u2014 includes history + anti-patterns), "extend" (add feature \u2014 includes deps + blast radius), "refactor" (restructure \u2014 includes importers + complexity), or "understand" (learn \u2014 includes full slice + architecture). This is the BEST starting point when you know both the symbol and your intent.',
+      inputSchema: {
+        symbolId: z15.string().min(1).describe("The symbol ID (format: file::name::kind)"),
+        taskType: z15.enum(["fix", "extend", "refactor", "understand"]).describe("Task type determines which context is most relevant"),
+        tokenBudget: z15.number().optional().default(4e3).describe("Max tokens for context (default 4000)")
+      },
+      annotations: toolAnnotations
+    },
+    (args2) => contextForTaskHandler(args2)
+  );
+  const rankedContextHandler = handleGetRankedContext(storage, masking, staleness, ctxoRoot);
+  server.registerTool(
+    "get_ranked_context",
+    {
+      description: "Search and rank symbols by relevance to a natural language query, packed within a token budget. Uses BM25 text matching + PageRank importance scoring. Results include `_meta` with truncation info. Use this when you have a question or topic but do not know which specific symbol to look at. For exact symbol name search, use search_symbols instead.",
+      inputSchema: {
+        query: z15.string().min(1).describe("Search query (matches symbol names)"),
+        tokenBudget: z15.number().optional().default(4e3).describe("Max tokens for results (default 4000)"),
+        strategy: z15.enum(["combined", "dependency", "importance"]).optional().default("combined").describe("Ranking strategy")
+      },
+      annotations: toolAnnotations
+    },
+    (args2) => rankedContextHandler(args2)
+  );
+  const searchSymbolsHandler = handleSearchSymbols(storage, masking, staleness, ctxoRoot);
+  server.registerTool(
+    "search_symbols",
+    {
+      description: "Search symbols by exact name or regex pattern across the codebase index. Use this when you know (part of) the symbol name and need to find its ID for use with other tools. For semantic/relevance-based search, use get_ranked_context instead.",
+      inputSchema: {
+        pattern: z15.string().min(1).describe("Search pattern (substring or regex)"),
+        kind: z15.enum(["function", "class", "interface", "method", "variable", "type"]).optional().describe("Filter by symbol kind"),
+        filePattern: z15.string().optional().describe("Filter by file path substring"),
+        limit: z15.number().int().min(1).max(100).optional().default(25).describe("Max results (default 25)")
+      },
+      annotations: toolAnnotations
+    },
+    (args2) => searchSymbolsHandler(args2)
+  );
+  const changedSymbolsHandler = handleGetChangedSymbols(storage, git, masking, staleness, ctxoRoot);
+  server.registerTool(
+    "get_changed_symbols",
+    {
+      description: "Get symbols in recently changed files based on git diff. Use this to see what was modified in recent commits. For full PR risk assessment (changed symbols + blast radius + co-changes), use get_pr_impact instead.",
+      inputSchema: {
+        since: z15.string().optional().default("HEAD~1").describe("Git ref to diff against (default HEAD~1)"),
+        maxFiles: z15.number().int().min(1).optional().default(50).describe("Max changed files to process (default 50)")
+      },
+      annotations: toolAnnotations
+    },
+    (args2) => changedSymbolsHandler(args2)
+  );
+  const findImportersHandler = handleFindImporters(storage, masking, staleness, ctxoRoot);
+  server.registerTool(
+    "find_importers",
+    {
+      description: 'Find all symbols that import or depend on a given symbol (reverse dependency / "who uses this?"). Use this to check if a symbol is safe to modify or delete. Supports transitive traversal for deep impact chains. Use `intent` to filter by keyword (e.g., "test", "core"). For forward dependencies (what this symbol uses), use get_logic_slice. For aggregated impact with risk scores, use get_blast_radius.',
+      inputSchema: {
+        symbolId: z15.string().min(1).describe("The symbol ID (format: file::name::kind)"),
+        edgeKinds: z15.array(z15.enum(["imports", "calls", "extends", "implements", "uses"])).optional().describe("Filter by edge kinds"),
+        transitive: z15.boolean().optional().default(false).describe("Follow transitive reverse edges (default false)"),
+        maxDepth: z15.number().int().min(1).max(10).optional().default(5).describe("Max BFS depth for transitive mode (default 5)"),
+        intent: z15.string().optional().describe('Filter importers by intent keywords (e.g., "test", "core", "adapter")')
+      },
+      annotations: toolAnnotations
+    },
+    (args2) => findImportersHandler(args2)
+  );
+  const classHierarchyHandler = handleGetClassHierarchy(storage, masking, staleness, ctxoRoot);
+  server.registerTool(
+    "get_class_hierarchy",
+    {
+      description: "Get class inheritance hierarchy \u2014 ancestors (extends/implements chain) and descendants (subclasses). Use this when working with OOP code to understand type relationships before modifying a base class or interface. For dependency-based relationships (imports/calls), use get_logic_slice or find_importers.",
+      inputSchema: {
+        symbolId: z15.string().min(1).optional().describe("Root symbol ID (omit for full project hierarchy)"),
+        direction: z15.enum(["ancestors", "descendants", "both"]).optional().default("both").describe("Traversal direction (default both)")
+      },
+      annotations: toolAnnotations
+    },
+    (args2) => classHierarchyHandler(args2)
+  );
+  const symbolImportanceHandler = handleGetSymbolImportance(storage, masking, staleness, ctxoRoot);
+  server.registerTool(
+    "get_symbol_importance",
+    {
+      description: "Rank symbols by structural importance using PageRank centrality on the dependency graph. Use this to identify the most critical symbols in the codebase \u2014 high-PageRank symbols are heavily depended upon and risky to change. For finding unused/unimportant code, use find_dead_code instead.",
+      inputSchema: {
+        limit: z15.number().int().min(1).max(200).optional().default(25).describe("Max results (default 25)"),
+        kind: z15.enum(["function", "class", "interface", "method", "variable", "type"]).optional().describe("Filter by symbol kind"),
+        filePattern: z15.string().optional().describe("Filter by file path substring"),
+        damping: z15.number().min(0).max(1).optional().default(0.85).describe("PageRank damping factor (default 0.85)")
+      },
+      annotations: toolAnnotations
+    },
+    (args2) => symbolImportanceHandler(args2)
+  );
+  const prImpactHandler = handleGetPrImpact(storage, git, masking, staleness, ctxoRoot);
+  server.registerTool(
+    "get_pr_impact",
+    {
+      description: "Analyze the full impact of a PR or recent changes in a SINGLE call \u2014 combines changed symbols + blast radius + co-change history into one risk assessment. Results include `_meta` with truncation info. Use this FIRST when reviewing a PR or evaluating recent commits. For single-symbol analysis, use get_blast_radius instead.",
+      inputSchema: {
+        since: z15.string().optional().default("HEAD~1").describe("Git ref to diff against (default HEAD~1)"),
+        maxFiles: z15.number().int().min(1).optional().default(50).describe("Max changed files to analyze"),
+        confidence: z15.enum(["confirmed", "likely", "potential"]).optional().describe("Filter impacted symbols by confidence tier")
+      },
+      annotations: toolAnnotations
+    },
+    (args2) => prImpactHandler(args2)
+  );
+  server.resource("ctxo-status", "ctxo://status", async (uri) => ({
+    contents: [{ uri: uri.href, text: "Ctxo MCP server is running." }]
+  }));
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
 main().catch((err) => {
-  console.error("[ctxo] Fatal:", err.message);
+  log.error("Fatal: %s", err.message);
   process.exit(1);
 });
 //# sourceMappingURL=index.js.map