trace-mcp 1.2.1 → 1.4.1

package/dist/index.js

@@ -2522,6 +2522,16 @@ function buildProjectContext(rootPath) {
     } catch {
     }
   }
+  try {
+    const ghWorkflowDir = path.resolve(rootPath, ".github/workflows");
+    const entries = fs.readdirSync(ghWorkflowDir);
+    for (const entry of entries) {
+      if (entry.endsWith(".yml") || entry.endsWith(".yaml")) {
+        configFiles.push(`.github/workflows/${entry}`);
+      }
+    }
+  } catch {
+  }
   return {
     rootPath,
     packageJson,
@@ -3310,69 +3320,557 @@ function buildNode(store, comp, filePath, remainingDepth, visited, budget) {
   return node;
 }
 
+// src/tools/git-analysis.ts
+import { execFileSync } from "child_process";
+
+// src/logger.ts
+import pino from "pino";
+var level = process.env.TRACE_MCP_LOG_LEVEL ?? "info";
+var logger = pino({
+  name: "trace-mcp",
+  level
+}, process.stderr);
+
+// src/tools/git-analysis.ts
+function isGitRepo(cwd) {
+  try {
+    execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd,
+      stdio: "pipe",
+      timeout: 5e3
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getGitFileStats(cwd, sinceDays) {
+  const args = [
+    "log",
+    "--pretty=format:__COMMIT__%H|%aI|%aN",
+    "--name-only",
+    "--no-merges",
+    "--diff-filter=ACDMR"
+  ];
+  if (sinceDays !== void 0) {
+    args.push(`--since=${sinceDays} days ago`);
+  }
+  let output;
+  try {
+    output = execFileSync("git", args, {
+      cwd,
+      stdio: "pipe",
+      maxBuffer: 10 * 1024 * 1024,
+      // 10 MB
+      timeout: 3e4
+    }).toString("utf-8");
+  } catch (e) {
+    logger.warn({ error: e }, "git log failed");
+    return /* @__PURE__ */ new Map();
+  }
+  const fileStats = /* @__PURE__ */ new Map();
+  let currentDate = null;
+  let currentAuthor = null;
+  for (const line of output.split("\n")) {
+    if (line.startsWith("__COMMIT__")) {
+      const parts = line.slice("__COMMIT__".length).split("|");
+      currentDate = new Date(parts[1]);
+      currentAuthor = parts[2];
+      continue;
+    }
+    const trimmed = line.trim();
+    if (!trimmed || !currentDate || !currentAuthor) continue;
+    const existing = fileStats.get(trimmed);
+    if (existing) {
+      existing.commits++;
+      existing.authors.add(currentAuthor);
+      if (currentDate < existing.firstDate) existing.firstDate = currentDate;
+      if (currentDate > existing.lastDate) existing.lastDate = currentDate;
+    } else {
+      fileStats.set(trimmed, {
+        file: trimmed,
+        commits: 1,
+        authors: /* @__PURE__ */ new Set([currentAuthor]),
+        firstDate: currentDate,
+        lastDate: currentDate
+      });
+    }
+  }
+  return fileStats;
+}
+function getChurnRate(cwd, options = {}) {
+  const { sinceDays, limit = 50, filePattern } = options;
+  if (!isGitRepo(cwd)) {
+    return [];
+  }
+  const stats = getGitFileStats(cwd, sinceDays);
+  let entries = [];
+  for (const [file, data] of stats) {
+    if (filePattern && !file.includes(filePattern)) continue;
+    const lifespanMs = data.lastDate.getTime() - data.firstDate.getTime();
+    const lifespanWeeks = Math.max(lifespanMs / (7 * 24 * 60 * 60 * 1e3), 1);
+    const churnPerWeek = Math.round(data.commits / lifespanWeeks * 100) / 100;
+    let assessment;
+    if (churnPerWeek <= 1) assessment = "stable";
+    else if (churnPerWeek <= 3) assessment = "active";
+    else assessment = "volatile";
+    entries.push({
+      file,
+      commits: data.commits,
+      unique_authors: data.authors.size,
+      first_seen: data.firstDate.toISOString().split("T")[0],
+      last_modified: data.lastDate.toISOString().split("T")[0],
+      churn_per_week: churnPerWeek,
+      assessment
+    });
+  }
+  entries.sort((a, b) => b.commits - a.commits);
+  return entries.slice(0, limit);
+}
+function getHotspots(store, cwd, options = {}) {
+  const { sinceDays = 90, limit = 20, minCyclomatic = 3 } = options;
+  if (!isGitRepo(cwd)) {
+    return getComplexityOnlyHotspots(store, limit, minCyclomatic);
+  }
+  const gitStats = getGitFileStats(cwd, sinceDays);
+  const fileComplexity = getMaxCyclomaticPerFile(store);
+  const entries = [];
+  for (const [file, maxCyclomatic] of fileComplexity) {
+    if (maxCyclomatic < minCyclomatic) continue;
+    const git = gitStats.get(file);
+    const commits = git?.commits ?? 0;
+    const score = Math.round(maxCyclomatic * Math.log(1 + commits) * 100) / 100;
+    if (score <= 0) continue;
+    let assessment;
+    if (score <= 3) assessment = "low";
+    else if (score <= 10) assessment = "medium";
+    else assessment = "high";
+    entries.push({
+      file,
+      max_cyclomatic: maxCyclomatic,
+      commits,
+      score,
+      assessment
+    });
+  }
+  entries.sort((a, b) => b.score - a.score);
+  return entries.slice(0, limit);
+}
+function getMaxCyclomaticPerFile(store) {
+  const rows = store.db.prepare(`
+    SELECT f.path, MAX(s.cyclomatic) as max_cyclomatic
+    FROM symbols s
+    JOIN files f ON s.file_id = f.id
+    WHERE s.cyclomatic IS NOT NULL
+    GROUP BY f.path
+  `).all();
+  const result = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    result.set(row.path, row.max_cyclomatic);
+  }
+  return result;
+}
+function getComplexityOnlyHotspots(store, limit, minCyclomatic) {
+  const fileComplexity = getMaxCyclomaticPerFile(store);
+  const entries = [];
+  for (const [file, maxCyclomatic] of fileComplexity) {
+    if (maxCyclomatic < minCyclomatic) continue;
+    entries.push({
+      file,
+      max_cyclomatic: maxCyclomatic,
+      commits: 0,
+      score: maxCyclomatic,
+      // score = complexity alone
+      assessment: maxCyclomatic <= 3 ? "low" : maxCyclomatic <= 10 ? "medium" : "high"
+    });
+  }
+  entries.sort((a, b) => b.score - a.score);
+  return entries.slice(0, limit);
+}
+
 // src/tools/impact.ts
-function getChangeImpact(store, opts, depth = 3, maxDependents = 200) {
-  let startNodeId;
+import { execSync } from "child_process";
+function getModule(filePath, depth = 2) {
+  const parts = filePath.split("/");
+  return parts.length <= depth ? parts[0] : parts.slice(0, depth).join("/");
+}
+function riskLevel(score) {
+  if (score >= 0.75) return "critical";
+  if (score >= 0.5) return "high";
+  if (score >= 0.25) return "medium";
+  return "low";
+}
+function round(v, decimals = 2) {
+  const f = 10 ** decimals;
+  return Math.round(v * f) / f;
+}
+function clamp01(v, ceiling) {
+  return Math.min(v / ceiling, 1);
+}
+function getTestedFileIds(store) {
+  const rows = store.db.prepare(`
+    SELECT DISTINCT
+      CASE
+        WHEN n.node_type = 'file' THEN n.ref_id
+        WHEN n.node_type = 'symbol' THEN (SELECT file_id FROM symbols WHERE id = n.ref_id)
+      END AS fid
+    FROM edges e
+    JOIN edge_types et ON e.edge_type_id = et.id
+    JOIN nodes n ON e.target_node_id = n.id
+    WHERE et.name = 'test_covers'
+  `).all();
+  const set = /* @__PURE__ */ new Set();
+  for (const r of rows) if (r.fid != null) set.add(r.fid);
+  return set;
+}
+function getCoChangesForFile(store, filePath, graphFiles) {
+  try {
+    const rows = store.db.prepare(`
+      SELECT
+        CASE WHEN file_a = ? THEN file_b ELSE file_a END AS co_file,
+        confidence
+      FROM co_changes
+      WHERE (file_a = ? OR file_b = ?)
+        AND confidence >= 0.3
+        AND co_change_count >= 3
+      ORDER BY confidence DESC
+      LIMIT 15
+    `).all(filePath, filePath, filePath);
+    return rows.map((r) => ({
+      file: r.co_file,
+      confidence: round(r.confidence),
+      inGraph: graphFiles.has(r.co_file)
+    }));
+  } catch {
+    return [];
+  }
+}
+function findAffectedTests(store, targetPath, dependentPaths) {
+  const seen = /* @__PURE__ */ new Set();
+  const allPaths = [targetPath, ...dependentPaths];
+  for (const p of allPaths) {
+    const file = store.getFile(p);
+    if (!file) continue;
+    const fileNodeId = store.getNodeId("file", file.id);
+    if (fileNodeId != null) {
+      collectTestFiles(store, fileNodeId, seen);
+    }
+    const symbols = store.getSymbolsByFile(file.id);
+    for (const sym of symbols) {
+      const symNodeId = store.getNodeId("symbol", sym.id);
+      if (symNodeId != null) {
+        collectTestFiles(store, symNodeId, seen);
+      }
+    }
+  }
+  const files = [...seen].sort();
+  return { total: files.length, files };
+}
+function collectTestFiles(store, nodeId, seen) {
+  const incoming = store.getIncomingEdges(nodeId);
+  for (const edge of incoming) {
+    if (edge.edge_type_name !== "test_covers") continue;
+    const ref = store.getNodeRef(edge.source_node_id);
+    if (!ref) continue;
+    let fileId;
+    if (ref.nodeType === "file") {
+      fileId = ref.refId;
+    } else if (ref.nodeType === "symbol") {
+      const s = store.getSymbolById(ref.refId);
+      if (s) fileId = s.file_id;
+    }
+    if (fileId != null) {
+      const f = store.getFileById(fileId);
+      if (f) seen.add(f.path);
+    }
+  }
+}
+function getFileChurn(cwd, filePath, days) {
+  try {
+    const since = new Date(Date.now() - days * 864e5).toISOString().slice(0, 10);
+    const output = execSync(
+      `git log --since="${since}" --oneline -- "${filePath}" | wc -l`,
+      { cwd, encoding: "utf8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }
+    );
+    return parseInt(output.trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+function getChangeImpact(store, opts, depth = 3, maxDependents = 200, cwd) {
+  let startNodeIds = [];
   let targetPath;
   let targetSymbolId;
-  if (opts.symbolId) {
+  let targetSymbolName;
+  let targetKind;
+  let scopedToSymbols;
+  if (opts.symbolIds && opts.symbolIds.length > 0) {
+    scopedToSymbols = opts.symbolIds;
+    let firstSym;
+    for (const sid of opts.symbolIds) {
+      const sym = store.getSymbolBySymbolId(sid);
+      if (!sym) continue;
+      if (!firstSym) firstSym = sym;
+      const nid = store.getNodeId("symbol", sym.id);
+      if (nid != null) startNodeIds.push(nid);
+    }
+    if (!firstSym) {
+      return err(notFound(opts.symbolIds[0]));
+    }
+    const file = store.getFileById(firstSym.file_id);
+    targetPath = file?.path ?? "unknown";
+    targetSymbolId = firstSym.symbol_id;
+    targetSymbolName = firstSym.name;
+    targetKind = firstSym.kind;
+    startNodeIds = [...new Set(startNodeIds)];
+  } else if (opts.symbolId) {
     const sym = store.getSymbolBySymbolId(opts.symbolId);
     if (!sym) {
       return err(notFound(opts.symbolId));
     }
-    startNodeId = store.getNodeId("symbol", sym.id);
+    const nodeId = store.getNodeId("symbol", sym.id);
+    if (nodeId != null) startNodeIds.push(nodeId);
     const file = store.getFileById(sym.file_id);
     targetPath = file?.path ?? "unknown";
     targetSymbolId = opts.symbolId;
+    targetSymbolName = sym.name;
+    targetKind = sym.kind;
   } else if (opts.filePath) {
     const file = store.getFile(opts.filePath);
     if (!file) {
       return err(notFound(opts.filePath));
     }
     targetPath = file.path;
+    const fileNodeId = store.getNodeId("file", file.id);
+    if (fileNodeId != null) startNodeIds.push(fileNodeId);
     const symbols = store.getSymbolsByFile(file.id);
     const primarySymbol = symbols.find((s) => s.kind === "class") ?? symbols[0];
     if (primarySymbol) {
-      startNodeId = store.getNodeId("symbol", primarySymbol.id);
       targetSymbolId = primarySymbol.symbol_id;
-    } else {
-      startNodeId = store.getNodeId("file", file.id);
+      targetSymbolName = primarySymbol.name;
+      targetKind = primarySymbol.kind;
+    }
+    for (const sym of symbols) {
+      const nid = store.getNodeId("symbol", sym.id);
+      if (nid != null) startNodeIds.push(nid);
     }
+    startNodeIds = [...new Set(startNodeIds)];
   } else {
-    return err(notFound("", ["Provide either filePath or symbolId"]));
+    return err(notFound("", ["Provide either filePath, symbolId, or symbolIds"]));
   }
   const pennant = getPennantImpact(store, opts.symbolId ?? opts.filePath ?? "");
-  if (startNodeId == null) {
+  if (startNodeIds.length === 0) {
+    const emptySummary = {
+      totalFiles: 0,
+      totalSymbols: 0,
+      maxDepth: 0,
+      crossBoundary: false,
+      publicApiAffected: 0,
+      untestedDependents: 0,
+      highComplexityDependents: 0,
+      sentence: "No dependents found."
+    };
+    const emptyRisk = {
+      score: 0,
+      level: "low",
+      publicApiBreaking: false,
+      untestedRatio: 0,
+      maxComplexity: 0,
+      mitigations: []
+    };
     return ok({
-      target: { path: targetPath, symbolId: targetSymbolId },
+      target: { path: targetPath, symbolId: targetSymbolId, symbolName: targetSymbolName, kind: targetKind },
+      summary: emptySummary,
+      risk: emptyRisk,
       dependents: [],
+      affectedTests: { total: 0, files: [] },
       totalAffected: 0
     });
   }
-  const dependents = [];
+  const testedFileIds = getTestedFileIds(store);
+  const rawDeps = [];
   const visited = /* @__PURE__ */ new Set();
-  visited.add(startNodeId);
-  traverseIncoming(store, startNodeId, 1, depth, visited, dependents, maxDependents);
-  const truncated = dependents.length >= maxDependents;
-  return ok({
-    target: { path: targetPath, symbolId: targetSymbolId },
+  for (const nid of startNodeIds) visited.add(nid);
+  traverseIncoming(store, startNodeIds, maxDependents, depth, visited, rawDeps, testedFileIds);
+  const truncated = rawDeps.length >= maxDependents;
+  const dependents = deduplicateByFile(rawDeps);
+  const byEdgeType = {};
+  const byDepth = {};
+  for (const raw of rawDeps) {
+    byEdgeType[raw.edgeType] = (byEdgeType[raw.edgeType] ?? 0) + 1;
+    byDepth[raw.depth] = (byDepth[raw.depth] ?? 0) + 1;
+  }
+  const moduleMap = /* @__PURE__ */ new Map();
+  const graphFiles = /* @__PURE__ */ new Set();
+  const targetModule = getModule(targetPath);
+  let crossBoundary = false;
+  let publicApiAffected = 0;
+  let untestedDependents = 0;
+  let highComplexityDependents = 0;
+  let maxComplexity = 0;
+  let maxDepthSeen = 0;
+  for (const dep of dependents) {
+    const mod = getModule(dep.path);
+    if (mod !== targetModule) crossBoundary = true;
+    let modEntry = moduleMap.get(mod);
+    if (!modEntry) {
+      modEntry = { files: /* @__PURE__ */ new Set(), maxDepth: 0, hasUntested: false };
+      moduleMap.set(mod, modEntry);
+    }
+    modEntry.files.add(dep.path);
+    modEntry.maxDepth = Math.max(modEntry.maxDepth, dep.depth);
+    if (dep.hasTests === false) modEntry.hasUntested = true;
+    graphFiles.add(dep.path);
+    if (dep.hasTests === false) untestedDependents++;
+    if (dep.depth > maxDepthSeen) maxDepthSeen = dep.depth;
+    for (const sym of dep.symbols ?? []) {
+      if (sym.isExported) publicApiAffected++;
+      if ((sym.complexity ?? 0) > 15) highComplexityDependents++;
+      if ((sym.complexity ?? 0) > maxComplexity) maxComplexity = sym.complexity ?? 0;
+    }
+  }
+  const byModule = [...moduleMap.entries()].map(([mod, data]) => ({
+    module: mod,
+    count: data.files.size,
+    files: [...data.files],
+    maxDepth: data.maxDepth,
+    hasUntested: data.hasUntested
+  })).sort((a, b) => b.count - a.count);
+  const affectedTests = findAffectedTests(
+    store,
+    targetPath,
+    dependents.slice(0, 50).map((d) => d.path)
+  );
+  graphFiles.add(targetPath);
+  const coChangeAll = getCoChangesForFile(store, targetPath, graphFiles);
+  const coChangeHidden = coChangeAll.filter((c) => !c.inGraph);
+  const targetFile = store.getFile(targetPath);
+  const targetHasTests = targetFile ? testedFileIds.has(targetFile.id) : false;
+  let churnCommits = 0;
+  if (cwd && isGitRepo(cwd)) {
+    churnCommits = getFileChurn(cwd, targetPath, 180);
+  }
+  const totalFiles = dependents.length || 1;
+  const untestedRatio = round(untestedDependents / totalFiles);
+  const blastScore = clamp01(dependents.length, 50);
+  const complexityScore = clamp01(maxComplexity, 20);
+  const testGapScore = targetHasTests ? 0 : 0.8;
+  const churnScore = clamp01(churnCommits, 30);
+  const publicApiScore = publicApiAffected > 0 ? 0.3 : 0;
+  const riskScore = round(
+    0.3 * blastScore + 0.2 * complexityScore + 0.2 * testGapScore + 0.15 * churnScore + 0.15 * publicApiScore
+  );
+  const mitigations = [];
+  if (!targetHasTests) mitigations.push("Add test coverage for the target before modifying");
+  if (blastScore > 0.5) mitigations.push(`High blast radius (${dependents.length} files) \u2014 consider incremental rollout`);
+  if (complexityScore > 0.7) mitigations.push("High complexity in dependents \u2014 review carefully for regressions");
+  if (untestedRatio > 0.5) mitigations.push(`${untestedDependents}/${totalFiles} dependents lack tests \u2014 add integration tests`);
+  if (publicApiAffected > 0) mitigations.push(`${publicApiAffected} public API symbol(s) affected \u2014 check for breaking changes`);
+  if (churnCommits > 15) mitigations.push(`High churn (${churnCommits} commits/180d) \u2014 review recent history`);
+  if (coChangeHidden.length > 0) {
+    mitigations.push(`${coChangeHidden.length} hidden coupling(s) via git history: ${coChangeHidden.slice(0, 3).map((c) => c.file).join(", ")}`);
+  }
+  const risk = {
+    score: riskScore,
+    level: riskLevel(riskScore),
+    publicApiBreaking: publicApiAffected > 0,
+    untestedRatio,
+    maxComplexity,
+    mitigations
+  };
+  const modCount = byModule.length;
+  const symCount = dependents.reduce((s, d) => s + (d.symbols?.length ?? 0), 0);
+  const parts = [];
+  parts.push(`${dependents.length} file(s) across ${modCount} module(s)`);
+  if (publicApiAffected > 0) parts.push(`${publicApiAffected} public API`);
+  if (untestedDependents > 0) parts.push(`${untestedDependents} untested`);
+  if (highComplexityDependents > 0) parts.push(`${highComplexityDependents} high-complexity`);
+  if (affectedTests.total > 0) parts.push(`${affectedTests.total} test(s) to run`);
+  if (coChangeHidden.length > 0) parts.push(`${coChangeHidden.length} hidden coupling(s)`);
+  const summary = {
+    totalFiles: dependents.length,
+    totalSymbols: symCount,
+    maxDepth: maxDepthSeen,
+    crossBoundary,
+    publicApiAffected,
+    untestedDependents,
+    highComplexityDependents,
+    sentence: `Impact: ${parts.join(", ")}.${risk.level !== "low" ? ` Risk: ${risk.level}.` : ""}`
+  };
+  const breakingChanges = detectBreakingChanges(store, targetPath, scopedToSymbols);
+  if (breakingChanges.length > 0) {
+    const totalConsumers = breakingChanges.reduce((s, b) => s + b.consumers, 0);
+    mitigations.push(`${breakingChanges.length} exported symbol(s) with ${totalConsumers} consumer(s) \u2014 signature change = breaking`);
+    parts.push(`${breakingChanges.length} breaking risk(s)`);
+    summary.sentence = `Impact: ${parts.join(", ")}.${risk.level !== "low" ? ` Risk: ${risk.level}.` : ""}`;
+  }
+  const result = {
+    target: { path: targetPath, symbolId: targetSymbolId, symbolName: targetSymbolName, kind: targetKind },
+    summary,
+    risk,
+    affectedTests,
     dependents,
-    totalAffected: dependents.length,
-    ...truncated ? { truncated: true } : {},
-    ...pennant ? { pennant } : {}
-  });
+    totalAffected: dependents.length
+  };
+  if (breakingChanges.length > 0) result.breakingChanges = breakingChanges;
+  if (byModule.length > 0) result.byModule = byModule;
+  if (Object.keys(byEdgeType).length > 0) result.byEdgeType = byEdgeType;
+  if (Object.keys(byDepth).length > 0) result.byDepth = byDepth;
+  if (coChangeHidden.length > 0) result.coChangeHidden = coChangeHidden;
+  if (truncated) result.truncated = true;
+  if (pennant) result.pennant = pennant;
+  if (scopedToSymbols) result.scopedToSymbols = scopedToSymbols;
+  return ok(result);
 }
-function traverseIncoming(store, startNodeId, _currentDepth, maxDepth, visited, dependents, maxDependents) {
-  let frontier = [startNodeId];
+function deduplicateByFile(rawDeps) {
+  const fileMap = /* @__PURE__ */ new Map();
+  for (const raw of rawDeps) {
+    let entry = fileMap.get(raw.path);
+    if (!entry) {
+      entry = { edgeTypes: /* @__PURE__ */ new Set(), depth: raw.depth, hasTests: raw.hasTests, symbols: [] };
+      fileMap.set(raw.path, entry);
+    }
+    entry.edgeTypes.add(raw.edgeType);
+    entry.depth = Math.min(entry.depth, raw.depth);
+    if (raw.hasTests != null) entry.hasTests = raw.hasTests;
+    if (raw.symbolId && raw.symbolName && raw.symbolKind) {
+      if (!entry.symbols.some((s) => s.symbolId === raw.symbolId)) {
+        const sym = {
+          symbolId: raw.symbolId,
+          symbolName: raw.symbolName,
+          symbolKind: raw.symbolKind
+        };
+        if (raw.complexity != null) sym.complexity = raw.complexity;
+        if (raw.isExported != null) sym.isExported = raw.isExported;
+        entry.symbols.push(sym);
+      }
+    }
+  }
+  const result = [];
+  for (const [path43, entry] of fileMap) {
+    const dep = {
+      path: path43,
+      edgeTypes: [...entry.edgeTypes],
+      depth: entry.depth
+    };
+    if (entry.hasTests != null) dep.hasTests = entry.hasTests;
+    if (entry.symbols.length > 0) dep.symbols = entry.symbols;
+    result.push(dep);
+  }
+  result.sort((a, b) => a.depth - b.depth || a.path.localeCompare(b.path));
+  return result;
+}
+function traverseIncoming(store, startNodeIds, maxDependents, maxDepth, visited, rawDeps, testedFileIds) {
+  let frontier = startNodeIds;
   for (let depth = 1; depth <= maxDepth; depth++) {
-    if (frontier.length === 0 || dependents.length >= maxDependents) break;
+    if (frontier.length === 0 || rawDeps.length >= maxDependents) break;
     const allEdges = store.getEdgesForNodesBatch(frontier);
     const frontierSet = new Set(frontier);
     const newFrontier = [];
     const sourceNodeIds = [];
     const edgeBySource = /* @__PURE__ */ new Map();
     for (const edge of allEdges) {
-      if (dependents.length + sourceNodeIds.length >= maxDependents) break;
+      if (rawDeps.length + sourceNodeIds.length >= maxDependents) break;
       if (!frontierSet.has(edge.target_node_id)) continue;
       if (edge.source_node_id === edge.target_node_id) continue;
       const srcId = edge.source_node_id;
@@ -3395,32 +3893,112 @@ function traverseIncoming(store, startNodeId, _currentDepth, maxDepth, visited,
     const symFileIds = /* @__PURE__ */ new Set();
     for (const sym of symbolMap.values()) symFileIds.add(sym.file_id);
     const symFiles = symFileIds.size > 0 ? store.getFilesByIds([...symFileIds]) : /* @__PURE__ */ new Map();
+    const complexityMap = /* @__PURE__ */ new Map();
+    if (symbolIds.length > 0) {
+      const placeholders = symbolIds.map(() => "?").join(",");
+      const rows = store.db.prepare(
+        `SELECT id, cyclomatic FROM symbols WHERE id IN (${placeholders}) AND cyclomatic IS NOT NULL`
+      ).all(...symbolIds);
+      for (const r of rows) complexityMap.set(r.id, r.cyclomatic);
+    }
     for (const srcId of sourceNodeIds) {
-      if (dependents.length >= maxDependents) break;
+      if (rawDeps.length >= maxDependents) break;
       const ref = nodeRefs.get(srcId);
       if (!ref) continue;
-      let filePath;
-      let symbolId;
+      let filePath;
+      let symbolId;
+      let symbolName;
+      let symbolKind;
+      let complexity;
+      let isExported;
+      let fileId;
+      if (ref.nodeType === "symbol") {
+        const sym = symbolMap.get(ref.refId);
+        if (sym) {
+          symbolId = sym.symbol_id;
+          symbolName = sym.name;
+          symbolKind = sym.kind;
+          filePath = symFiles.get(sym.file_id)?.path;
+          fileId = sym.file_id;
+          complexity = complexityMap.get(sym.id);
+          if (sym.metadata) {
+            try {
+              const meta = JSON.parse(sym.metadata);
+              isExported = meta.exported === true || meta.exported === 1;
+            } catch {
+            }
+          }
+        }
+      } else if (ref.nodeType === "file") {
+        const f = fileMap.get(ref.refId);
+        filePath = f?.path;
+        fileId = f?.id;
+      }
+      if (filePath) {
+        rawDeps.push({
+          path: filePath,
+          edgeType: edgeBySource.get(srcId) ?? "unknown",
+          depth,
+          symbolId,
+          symbolName,
+          symbolKind,
+          complexity,
+          hasTests: fileId != null ? testedFileIds.has(fileId) : void 0,
+          isExported,
+          fileId
+        });
+      }
+    }
+    frontier = newFrontier;
+  }
+}
+function detectBreakingChanges(store, targetPath, scopedSymbolIds) {
+  const file = store.getFile(targetPath);
+  if (!file) return [];
+  const symbols = store.getSymbolsByFile(file.id);
+  const breaking = [];
+  for (const sym of symbols) {
+    if (!sym.metadata) continue;
+    let meta;
+    try {
+      meta = JSON.parse(sym.metadata);
+    } catch {
+      continue;
+    }
+    if (meta.exported !== true && meta.exported !== 1) continue;
+    if (scopedSymbolIds && !scopedSymbolIds.includes(sym.symbol_id)) continue;
+    const nodeId = store.getNodeId("symbol", sym.id);
+    if (nodeId == null) continue;
+    const incoming = store.getIncomingEdges(nodeId);
+    const consumerFiles = /* @__PURE__ */ new Set();
+    for (const edge of incoming) {
+      if (edge.edge_type_name === "test_covers") continue;
+      const ref = store.getNodeRef(edge.source_node_id);
+      if (!ref) continue;
       if (ref.nodeType === "symbol") {
-        const sym = symbolMap.get(ref.refId);
-        if (sym) {
-          symbolId = sym.symbol_id;
-          filePath = symFiles.get(sym.file_id)?.path;
+        const s = store.getSymbolById(ref.refId);
+        if (s) {
+          const f = store.getFileById(s.file_id);
+          if (f && f.path !== targetPath) consumerFiles.add(f.path);
         }
       } else if (ref.nodeType === "file") {
-        filePath = fileMap.get(ref.refId)?.path;
-      }
-      if (filePath) {
-        dependents.push({
-          path: filePath,
-          symbolId,
-          edgeType: edgeBySource.get(srcId) ?? "unknown",
-          depth
-        });
+        const f = store.getFileById(ref.refId);
+        if (f && f.path !== targetPath) consumerFiles.add(f.path);
       }
     }
-    frontier = newFrontier;
+    if (consumerFiles.size > 0) {
+      breaking.push({
+        symbolId: sym.symbol_id,
+        symbolName: sym.name,
+        kind: sym.kind,
+        consumers: consumerFiles.size,
+        consumerFiles: [...consumerFiles].slice(0, 10)
+        // cap for readability
+      });
+    }
   }
+  breaking.sort((a, b) => b.consumers - a.consumers);
+  return breaking;
 }
 function getPennantImpact(store, name) {
   if (!name) return null;
@@ -3750,14 +4328,6 @@ import path9 from "path";
 import { cpus } from "os";
 import fg2 from "fast-glob";
 
-// src/logger.ts
-import pino from "pino";
-var level = process.env.TRACE_MCP_LOG_LEVEL ?? "info";
-var logger = pino({
-  name: "trace-mcp",
-  level
-}, process.stderr);
-
 // src/plugin-api/executor.ts
 var DEFAULT_TIMEOUT_MS = 3e4;
 var MAX_SYMBOLS_PER_FILE = 1e4;
@@ -4289,166 +4859,6 @@ var GitignoreMatcher = class {
 
 // src/tools/history.ts
 import { execFileSync as execFileSync2 } from "child_process";
-
-// src/tools/git-analysis.ts
-import { execFileSync } from "child_process";
-function isGitRepo(cwd) {
-  try {
-    execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
-      cwd,
-      stdio: "pipe",
-      timeout: 5e3
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getGitFileStats(cwd, sinceDays) {
-  const args = [
-    "log",
-    "--pretty=format:__COMMIT__%H|%aI|%aN",
-    "--name-only",
-    "--no-merges",
-    "--diff-filter=ACDMR"
-  ];
-  if (sinceDays !== void 0) {
-    args.push(`--since=${sinceDays} days ago`);
-  }
-  let output;
-  try {
-    output = execFileSync("git", args, {
-      cwd,
-      stdio: "pipe",
-      maxBuffer: 10 * 1024 * 1024,
-      // 10 MB
-      timeout: 3e4
-    }).toString("utf-8");
-  } catch (e) {
-    logger.warn({ error: e }, "git log failed");
-    return /* @__PURE__ */ new Map();
-  }
-  const fileStats = /* @__PURE__ */ new Map();
-  let currentDate = null;
-  let currentAuthor = null;
-  for (const line of output.split("\n")) {
-    if (line.startsWith("__COMMIT__")) {
-      const parts = line.slice("__COMMIT__".length).split("|");
-      currentDate = new Date(parts[1]);
-      currentAuthor = parts[2];
-      continue;
-    }
-    const trimmed = line.trim();
-    if (!trimmed || !currentDate || !currentAuthor) continue;
-    const existing = fileStats.get(trimmed);
-    if (existing) {
-      existing.commits++;
-      existing.authors.add(currentAuthor);
-      if (currentDate < existing.firstDate) existing.firstDate = currentDate;
-      if (currentDate > existing.lastDate) existing.lastDate = currentDate;
-    } else {
-      fileStats.set(trimmed, {
-        file: trimmed,
-        commits: 1,
-        authors: /* @__PURE__ */ new Set([currentAuthor]),
-        firstDate: currentDate,
-        lastDate: currentDate
-      });
-    }
-  }
-  return fileStats;
-}
-function getChurnRate(cwd, options = {}) {
-  const { sinceDays, limit = 50, filePattern } = options;
-  if (!isGitRepo(cwd)) {
-    return [];
-  }
-  const stats = getGitFileStats(cwd, sinceDays);
-  let entries = [];
-  for (const [file, data] of stats) {
-    if (filePattern && !file.includes(filePattern)) continue;
-    const lifespanMs = data.lastDate.getTime() - data.firstDate.getTime();
-    const lifespanWeeks = Math.max(lifespanMs / (7 * 24 * 60 * 60 * 1e3), 1);
-    const churnPerWeek = Math.round(data.commits / lifespanWeeks * 100) / 100;
-    let assessment;
-    if (churnPerWeek <= 1) assessment = "stable";
-    else if (churnPerWeek <= 3) assessment = "active";
-    else assessment = "volatile";
-    entries.push({
-      file,
-      commits: data.commits,
-      unique_authors: data.authors.size,
-      first_seen: data.firstDate.toISOString().split("T")[0],
-      last_modified: data.lastDate.toISOString().split("T")[0],
-      churn_per_week: churnPerWeek,
-      assessment
-    });
-  }
-  entries.sort((a, b) => b.commits - a.commits);
-  return entries.slice(0, limit);
-}
-function getHotspots(store, cwd, options = {}) {
-  const { sinceDays = 90, limit = 20, minCyclomatic = 3 } = options;
-  if (!isGitRepo(cwd)) {
-    return getComplexityOnlyHotspots(store, limit, minCyclomatic);
-  }
-  const gitStats = getGitFileStats(cwd, sinceDays);
-  const fileComplexity = getMaxCyclomaticPerFile(store);
-  const entries = [];
-  for (const [file, maxCyclomatic] of fileComplexity) {
-    if (maxCyclomatic < minCyclomatic) continue;
-    const git = gitStats.get(file);
-    const commits = git?.commits ?? 0;
-    const score = Math.round(maxCyclomatic * Math.log(1 + commits) * 100) / 100;
-    if (score <= 0) continue;
-    let assessment;
-    if (score <= 3) assessment = "low";
-    else if (score <= 10) assessment = "medium";
-    else assessment = "high";
-    entries.push({
-      file,
-      max_cyclomatic: maxCyclomatic,
-      commits,
-      score,
-      assessment
-    });
-  }
-  entries.sort((a, b) => b.score - a.score);
-  return entries.slice(0, limit);
-}
-function getMaxCyclomaticPerFile(store) {
-  const rows = store.db.prepare(`
-    SELECT f.path, MAX(s.cyclomatic) as max_cyclomatic
-    FROM symbols s
-    JOIN files f ON s.file_id = f.id
-    WHERE s.cyclomatic IS NOT NULL
-    GROUP BY f.path
-  `).all();
-  const result = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    result.set(row.path, row.max_cyclomatic);
-  }
-  return result;
-}
-function getComplexityOnlyHotspots(store, limit, minCyclomatic) {
-  const fileComplexity = getMaxCyclomaticPerFile(store);
-  const entries = [];
-  for (const [file, maxCyclomatic] of fileComplexity) {
-    if (maxCyclomatic < minCyclomatic) continue;
-    entries.push({
-      file,
-      max_cyclomatic: maxCyclomatic,
-      commits: 0,
-      score: maxCyclomatic,
-      // score = complexity alone
-      assessment: maxCyclomatic <= 3 ? "low" : maxCyclomatic <= 10 ? "medium" : "high"
-    });
-  }
-  entries.sort((a, b) => b.score - a.score);
-  return entries.slice(0, limit);
-}
-
-// src/tools/history.ts
 function sampleFileCommits(cwd, filePath, sinceDays, count) {
   const args = [
     "log",
@@ -7690,7 +8100,7 @@ function registerAITools(server, ctx) {
     },
     async ({ file_path, diff }) => {
       const impactResult = getChangeImpact(store, { filePath: file_path });
-      const blastRadius = impactResult.isOk() ? impactResult.value.dependents.map((d) => `${d.edgeType}: ${d.path}`).join("\n") : "";
+      const blastRadius = impactResult.isOk() ? impactResult.value.dependents.map((d) => `${d.edgeTypes.join(", ")}: ${d.path}`).join("\n") : "";
       const prompt = PROMPTS.review_change.build({
         filePath: file_path,
         diff: diff ?? "",
@@ -8901,7 +9311,14 @@ var CALL_EDGE_TYPES = /* @__PURE__ */ new Set([
   "routes_to",
   "validates_with",
   "nest_injects",
-  "graphql_resolves"
+  "graphql_resolves",
+  // Import-based edges (fallback when no call edges exist)
+  "esm_imports",
+  "imports",
+  "uses",
+  // Component/rendering edges
+  "renders_component",
+  "uses_composable"
 ]);
 var MAX_DEPTH = 10;
 function getCallGraph(store, opts, depth = 2) {
@@ -11214,6 +11631,10 @@ async function getTaskContext(store, rootPath, opts, ai) {
     const recency = computeRecency(file.indexed_at, now);
     const typeBonus = getTypeBonus(sym.kind);
     let score = hybridScore({ relevance, pagerank: pr, recency, typeBonus });
+    const NON_CODE_LANGUAGES = /* @__PURE__ */ new Set(["markdown", "yaml", "json", "toml", "xml", "html", "csv", "text", "ini"]);
+    if (file.language && NON_CODE_LANGUAGES.has(file.language.toLowerCase())) {
+      score *= 0.2;
+    }
     if (walkInfo.depth > 0) {
       score *= 1 / (1 + 0.3 * walkInfo.depth);
     }
@@ -11478,7 +11899,7 @@ function rankPercentile(values) {
 function clampNormalize(value, ceiling) {
   return Math.min(1, value / ceiling);
 }
-function riskLevel(score) {
+function riskLevel2(score) {
   if (score < 0.3) return "low";
   if (score < 0.5) return "medium";
   if (score < 0.75) return "high";
@@ -11491,7 +11912,7 @@ function debtGrade(score) {
   if (score < 0.8) return "D";
   return "F";
 }
-function getModule(filePath, depth) {
+function getModule2(filePath, depth) {
   const parts = filePath.split("/");
   return parts.slice(0, Math.min(depth, parts.length - 1)).join("/") || filePath;
 }
@@ -11548,14 +11969,14 @@ function predictBugs(store, cwd, options = {}) {
     predictions.push({
       file,
       score: Math.round(score * 1e3) / 1e3,
-      risk: riskLevel(score),
+      risk: riskLevel2(score),
       factors: [
-        { signal: "churn", raw_value: round(git?.churnPerWeek ?? 0), normalized: round(sChurn), weight: w.churn, contribution: round(w.churn * sChurn) },
-        { signal: "fix_ratio", raw_value: round(git?.fixRatio ?? 0), normalized: round(sFixRatio), weight: w.fix_ratio, contribution: round(w.fix_ratio * sFixRatio) },
-        { signal: "complexity", raw_value: complexityMap.get(file) ?? 0, normalized: round(sComplexity), weight: w.complexity, contribution: round(w.complexity * sComplexity) },
-        { signal: "coupling", raw_value: round(coupling?.instability ?? 0), normalized: round(sCoupling), weight: w.coupling, contribution: round(w.coupling * sCoupling) },
-        { signal: "pagerank", raw_value: round(pagerankMap.get(file)?.score ?? 0), normalized: round(sPagerank), weight: w.pagerank, contribution: round(w.pagerank * sPagerank) },
-        { signal: "authors", raw_value: git?.authors ?? 0, normalized: round(sAuthors), weight: w.authors, contribution: round(w.authors * sAuthors) }
+        { signal: "churn", raw_value: round2(git?.churnPerWeek ?? 0), normalized: round2(sChurn), weight: w.churn, contribution: round2(w.churn * sChurn) },
+        { signal: "fix_ratio", raw_value: round2(git?.fixRatio ?? 0), normalized: round2(sFixRatio), weight: w.fix_ratio, contribution: round2(w.fix_ratio * sFixRatio) },
+        { signal: "complexity", raw_value: complexityMap.get(file) ?? 0, normalized: round2(sComplexity), weight: w.complexity, contribution: round2(w.complexity * sComplexity) },
+        { signal: "coupling", raw_value: round2(coupling?.instability ?? 0), normalized: round2(sCoupling), weight: w.coupling, contribution: round2(w.coupling * sCoupling) },
+        { signal: "pagerank", raw_value: round2(pagerankMap.get(file)?.score ?? 0), normalized: round2(sPagerank), weight: w.pagerank, contribution: round2(w.pagerank * sPagerank) },
+        { signal: "authors", raw_value: git?.authors ?? 0, normalized: round2(sAuthors), weight: w.authors, contribution: round2(w.authors * sAuthors) }
       ]
     });
   }
@@ -11590,7 +12011,7 @@ function detectDrift(store, cwd, options = {}) {
     for (const file of files) {
       fileCommitCount.set(file, (fileCommitCount.get(file) ?? 0) + 1);
       fileTotalCount.set(file, (fileTotalCount.get(file) ?? 0) + 1);
-      modulesTouched.add(getModule(file, moduleDepth));
+      modulesTouched.add(getModule2(file, moduleDepth));
     }
     const isShotgun = modulesTouched.size >= 3;
     if (isShotgun) {
@@ -11611,8 +12032,8 @@ function detectDrift(store, cwd, options = {}) {
   const anomalies = [];
   for (const [key, count] of coChangeCount) {
     const [fileA, fileB] = key.split("|");
-    const moduleA = getModule(fileA, moduleDepth);
-    const moduleB = getModule(fileB, moduleDepth);
+    const moduleA = getModule2(fileA, moduleDepth);
+    const moduleB = getModule2(fileB, moduleDepth);
     if (moduleA === moduleB) continue;
     const commitsA = fileCommitCount.get(fileA) ?? 0;
     const commitsB = fileCommitCount.get(fileB) ?? 0;
@@ -11624,7 +12045,7 @@ function detectDrift(store, cwd, options = {}) {
       file_a: fileA,
       file_b: fileB,
       co_change_count: count,
-      confidence: round(jaccard2),
+      confidence: round2(jaccard2),
       module_a: moduleA,
       module_b: moduleB
     });
@@ -11639,7 +12060,7 @@ function detectDrift(store, cwd, options = {}) {
         file,
         shotgun_commits: shotgunCommits,
         total_commits: total,
-        ratio: round(ratio)
+        ratio: round2(ratio)
       });
     }
   }
@@ -11686,7 +12107,7 @@ function getTechDebt(store, cwd, options = {}) {
   const allFiles = store.getAllFiles();
   const moduleFiles = /* @__PURE__ */ new Map();
   for (const f of allFiles) {
-    const mod = getModule(f.path, moduleDepth);
+    const mod = getModule2(f.path, moduleDepth);
     if (!moduleFiles.has(mod)) moduleFiles.set(mod, []);
     moduleFiles.get(mod).push(f.path);
   }
@@ -11722,7 +12143,7 @@ function getTechDebt(store, cwd, options = {}) {
     }
     if (sCoupling > 0.7) {
       recommendations.push({
-        action: `Reduce coupling: module has high average instability (${round(sCoupling)})`,
+        action: `Reduce coupling: module has high average instability (${round2(sCoupling)})`,
         target: mod,
         priority: "medium"
       });
@@ -11746,13 +12167,13 @@ function getTechDebt(store, cwd, options = {}) {
     }
     modules.push({
       module: mod,
-      score: round(score),
+      score: round2(score),
       grade: debtGrade(score),
       breakdown: {
-        complexity: round(sComplexity),
-        coupling: round(sCoupling),
-        test_gap: round(sTestGap),
-        churn: round(sChurn)
+        complexity: round2(sComplexity),
+        coupling: round2(sCoupling),
+        test_gap: round2(sTestGap),
+        churn: round2(sChurn)
       },
       file_count: files.length,
       recommendations
@@ -11762,7 +12183,7 @@ function getTechDebt(store, cwd, options = {}) {
   const totalScore = modules.length > 0 ? modules.reduce((s, m) => s + m.score, 0) / modules.length : 0;
   return ok({
     modules: modules.slice(0, 50),
-    project_score: round(totalScore),
+    project_score: round2(totalScore),
     project_grade: debtGrade(totalScore)
   });
 }
@@ -11859,15 +12280,15 @@ function assessChangeRisk(store, cwd, opts) {
   if (sChurn > 0.7) mitigations.push("Frequently changed file \u2014 review recent change history for context");
   return ok({
     target: { file: targetFile, symbol_id: targetSymbolId },
-    risk_score: round(riskScore),
-    risk_level: riskLevel(riskScore),
-    confidence: round(confidence),
+    risk_score: round2(riskScore),
+    risk_level: riskLevel2(riskScore),
+    confidence: round2(confidence),
     factors: [
-      { signal: "blast_radius", value: round(sBlast), weight: w.blast_radius, contribution: round(w.blast_radius * sBlast), detail: `${blastFiles} files, ${blastSymbols} symbols in blast radius` },
-      { signal: "complexity", value: round(sComplexity), weight: w.complexity, contribution: round(w.complexity * sComplexity), detail: `Max cyclomatic: ${complexityRow?.max_cyc ?? 0}` },
-      { signal: "churn", value: round(sChurn), weight: w.churn, contribution: round(w.churn * sChurn), detail: gitAvailable ? `Churn percentile: ${round(sChurn * 100)}%` : "Git unavailable" },
-      { signal: "test_gap", value: sTestGap, weight: w.test_gap, contribution: round(w.test_gap * sTestGap), detail: hasTestCoverage ? "Has test coverage" : "No test coverage" },
-      { signal: "coupling", value: round(sCoupling), weight: w.coupling, contribution: round(w.coupling * sCoupling), detail: `Instability: ${round(sCoupling)}` }
+      { signal: "blast_radius", value: round2(sBlast), weight: w.blast_radius, contribution: round2(w.blast_radius * sBlast), detail: `${blastFiles} files, ${blastSymbols} symbols in blast radius` },
+      { signal: "complexity", value: round2(sComplexity), weight: w.complexity, contribution: round2(w.complexity * sComplexity), detail: `Max cyclomatic: ${complexityRow?.max_cyc ?? 0}` },
+      { signal: "churn", value: round2(sChurn), weight: w.churn, contribution: round2(w.churn * sChurn), detail: gitAvailable ? `Churn percentile: ${round2(sChurn * 100)}%` : "Git unavailable" },
+      { signal: "test_gap", value: sTestGap, weight: w.test_gap, contribution: round2(w.test_gap * sTestGap), detail: hasTestCoverage ? "Has test coverage" : "No test coverage" },
+      { signal: "coupling", value: round2(sCoupling), weight: w.coupling, contribution: round2(w.coupling * sCoupling), detail: `Instability: ${round2(sCoupling)}` }
     ],
     mitigations,
     blast_radius: { files: blastFiles, symbols: blastSymbols }
@@ -11950,7 +12371,7 @@ function getCachedBugPredictions(store, limit, minScore, filePattern, ttlMs = 60
       predictions: rows.map((r) => ({
         file: r.file_path,
         score: r.score,
-        risk: riskLevel(r.score),
+        risk: riskLevel2(r.score),
         factors: JSON.parse(r.factors || "[]")
       })),
       total_files_analyzed: snapshotFull?.file_count ?? rows.length,
@@ -12020,7 +12441,7 @@ function saveBugPredictionCache(store, predictions, cwd) {
     return null;
   }
 }
-function round(v, decimals = 3) {
+function round2(v, decimals = 3) {
   const m = 10 ** decimals;
   return Math.round(v * m) / m;
 }
@@ -13855,7 +14276,7 @@ function searchText(store, projectRoot, opts) {
     filePattern,
     language,
     maxResults = 50,
-    contextLines = 2,
+    contextLines = 0,
     caseSensitive = false
   } = opts;
   if (!query || query.length === 0) {
@@ -13878,7 +14299,7 @@ function searchText(store, projectRoot, opts) {
     files = store.db.prepare("SELECT * FROM files WHERE status != ?").all("error");
   }
   if (filePattern) {
-    const isMatch = (0, import_picomatch.default)(filePattern, { matchBase: true });
+    const isMatch = (0, import_picomatch.default)(filePattern, { dot: true });
     files = files.filter((f) => isMatch(f.path));
   }
   const matches = [];
@@ -13992,7 +14413,7 @@ function buildGraphData(store, opts) {
   } else {
     const allFiles = store.getAllFiles();
     if (scope.includes("*")) {
-      const isMatch = (0, import_picomatch2.default)(scope, { matchBase: true });
+      const isMatch = (0, import_picomatch2.default)(scope, { dot: true });
       seedFiles = allFiles.filter((f) => isMatch(f.path));
     } else if (scope.endsWith("/") || !scope.includes(".")) {
       seedFiles = allFiles.filter((f) => f.path.startsWith(scope.replace(/\/$/, "")));
@@ -15362,11 +15783,11 @@ function getCrossServiceImpact(topoStore, projectRoot, additionalRepos, opts) {
       });
     }
   }
-  const riskLevel2 = affected.length >= 3 ? "high" : affected.length >= 1 ? "medium" : "low";
+  const riskLevel3 = affected.length >= 3 ? "high" : affected.length >= 1 ? "medium" : "low";
   return ok({
     target: { service: opts.service, endpoint: opts.endpoint, event: opts.event },
     affected_services: affected,
-    risk_level: riskLevel2
+    risk_level: riskLevel3
   });
 }
 function getApiContract(topoStore, projectRoot, additionalRepos, opts) {
@@ -15960,7 +16381,7 @@ var FederationManager = class {
         }
       }
       const uniqueRepos = new Set(clients.map((c) => c.repo));
-      const riskLevel2 = uniqueRepos.size >= 3 ? "critical" : uniqueRepos.size >= 2 ? "high" : clients.length >= 3 ? "medium" : "low";
+      const riskLevel3 = uniqueRepos.size >= 3 ? "critical" : uniqueRepos.size >= 2 ? "high" : clients.length >= 3 ? "medium" : "low";
       const svc = this.topoStore.getAllServices().find((s) => s.id === ep.service_id);
       const repo = svc ? this.topoStore.getFederatedRepo(svc.repo_root) : void 0;
       results.push({
@@ -15971,7 +16392,7 @@ var FederationManager = class {
           repo: repo?.name ?? svc?.repo_root ?? "unknown"
         },
         clients,
-        riskLevel: riskLevel2,
+        riskLevel: riskLevel3,
         summary: `${ep.method ?? "*"} ${ep.path} is called by ${clients.length} client(s) in ${uniqueRepos.size} repo(s)`
       });
     }
@@ -16467,6 +16888,34 @@ var hintGenerators = {
       }
     }
     return hints;
+  },
+  batch(r) {
+    const hints = [];
+    const results = arr(dig(r, "batch_results"));
+    if (results.length > 0) {
+      hints.push({ tool: "get_session_stats", args: {}, why: "Check token savings from this batch vs individual calls" });
+    }
+    return hints;
+  },
+  get_optimization_report(r) {
+    const hints = [];
+    const opts = arr(dig(r, "optimizations"));
+    const hasRepeated = opts.some((o) => str(o?.rule) === "repeated-file-read");
+    if (hasRepeated) {
+      hints.push({ tool: "get_outline", args: { path: "<frequently_read_file>" }, why: "Use get_outline + get_symbol instead of repeated full-file reads" });
+    }
+    hints.push({ tool: "get_real_savings", args: { period: "today" }, why: "See actual per-file token savings breakdown" });
+    return hints;
+  },
+  get_real_savings(r) {
+    const hints = [];
+    hints.push({ tool: "get_session_stats", args: {}, why: "See per-tool call counts and savings for this session" });
+    return hints;
+  },
+  get_session_stats(r) {
+    const hints = [];
+    hints.push({ tool: "get_optimization_report", args: { period: "today" }, why: "Find specific waste patterns to fix" });
+    return hints;
   }
 };
 function getHints(toolName, result, max = 3) {
@@ -18942,14 +19391,14 @@ function generatePrTemplate(input, affected, risk) {
 }
 
 // src/tools/co-changes.ts
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 function collectCoChanges(rootPath, windowDays = 180) {
   const sinceDate = /* @__PURE__ */ new Date();
   sinceDate.setDate(sinceDate.getDate() - windowDays);
   const since = sinceDate.toISOString().split("T")[0];
   let gitOutput;
   try {
-    gitOutput = execSync(
+    gitOutput = execSync2(
       `git log --name-only --pretty=format:"COMMIT:%H:%aI" --since="${since}" --diff-filter=AMRD`,
       { cwd: rootPath, maxBuffer: 50 * 1024 * 1024, encoding: "utf-8", timeout: 3e4 }
     );
@@ -19061,12 +19510,12 @@ function getCoChanges(store, opts) {
 }
 
 // src/tools/changed-symbols.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 function getChangedSymbols(store, rootPath, opts) {
   const until = opts.until ?? "HEAD";
   let diffNameStatus;
   try {
-    diffNameStatus = execSync2(
+    diffNameStatus = execSync3(
       `git diff --name-status --diff-filter=AMRD ${opts.since}..${until}`,
       { cwd: rootPath, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024, timeout: 15e3 }
     ).trim();
@@ -19092,7 +19541,7 @@ function getChangedSymbols(store, rootPath, opts) {
   }
   let diffUnified = "";
   try {
-    diffUnified = execSync2(
+    diffUnified = execSync3(
       `git diff --unified=0 ${opts.since}..${until}`,
       { cwd: rootPath, encoding: "utf-8", maxBuffer: 50 * 1024 * 1024, timeout: 3e4 }
     );
@@ -19213,14 +19662,14 @@ function compareBranches(store, rootPath, opts) {
   const branch = opts.branch;
   let mergeBase;
   try {
-    mergeBase = execSync2(
+    mergeBase = execSync3(
       `git merge-base ${base} ${branch}`,
       { cwd: rootPath, encoding: "utf-8", timeout: 1e4 }
     ).trim();
   } catch (e) {
     if (base === "main") {
       try {
-        mergeBase = execSync2(
+        mergeBase = execSync3(
           `git merge-base master ${branch}`,
           { cwd: rootPath, encoding: "utf-8", timeout: 1e4 }
         ).trim();
@@ -19233,7 +19682,7 @@ function compareBranches(store, rootPath, opts) {
   }
   let commitCount = 0;
   try {
-    const countOutput = execSync2(
+    const countOutput = execSync3(
       `git rev-list --count ${mergeBase}..${branch}`,
       { cwd: rootPath, encoding: "utf-8", timeout: 1e4 }
     ).trim();
@@ -19291,6 +19740,7 @@ var SAVINGS_PATH = path33.join(TRACE_MCP_HOME, "savings.json");
 var RAW_COST_ESTIMATES = {
   get_symbol: 800,
   search: 600,
+  search_text: 3e3,
   get_outline: 1200,
   get_change_impact: 2e3,
   get_feature_context: 4e3,
@@ -20684,6 +21134,40 @@ function benchmarkCallGraph(store, symbols, count, rand) {
   });
   return buildScenario("call_graph", "Trace call graph (baseline: read all caller/callee files)", details);
 }
+function benchmarkTaskContext(store, symbols, files, count, rand) {
+  const sampled = sample(symbols.filter((s) => s.kind === "function" || s.kind === "class"), count, rand);
+  const details = sampled.map((s) => {
+    const nodeRow = store.db.prepare(
+      "SELECT n.id FROM nodes n JOIN symbols sym ON n.ref_id = sym.id AND n.node_type = ? WHERE sym.symbol_id = ?"
+    ).get("symbol", s.symbol_id);
+    let relatedFileBytes = 0;
+    let relatedFileCount = 0;
+    if (nodeRow) {
+      const related = store.db.prepare(`
+        SELECT DISTINCT f.byte_length FROM (
+          SELECT source_node_id AS nid FROM edges WHERE target_node_id = ?
+          UNION
+          SELECT target_node_id AS nid FROM edges WHERE source_node_id = ?
+        ) r
+        JOIN nodes n2 ON r.nid = n2.id AND n2.node_type = 'symbol'
+        JOIN symbols s2 ON n2.ref_id = s2.id
+        JOIN files f ON s2.file_id = f.id
+        LIMIT 10
+      `).all(nodeRow.id, nodeRow.id);
+      relatedFileBytes = related.reduce((sum, d) => sum + (d.byte_length || 0), 0);
+      relatedFileCount = related.length;
+    }
+    const targetFileBytes = s.file_byte_length;
+    const additionalFiles = Math.min(relatedFileCount, 5);
+    const avgRelatedSize = relatedFileCount > 0 ? relatedFileBytes / relatedFileCount : s.file_byte_length;
+    const totalReadBytes = targetFileBytes + additionalFiles * avgRelatedSize;
+    const grepOverhead = 2 * 5 * 20 * 80;
+    const bl = estimateTokens2(totalReadBytes + grepOverhead);
+    const tm = estimateTokens2(Math.round(totalReadBytes * 0.08));
+    return { query: `task: understand ${s.name}`, file: s.file_path, baseline_tokens: bl, trace_mcp_tokens: tm, reduction_pct: reductionPct(bl, tm) };
+  });
+  return buildScenario("composite_task", "NL task \u2192 optimal code context (baseline: search + read 5-8 files + grep)", details);
+}
 function runBenchmark(store, opts = {}) {
   const n = opts.queries ?? 10;
   const rand = seededRandom(opts.seed ?? 42);
@@ -20694,7 +21178,8 @@ function runBenchmark(store, opts = {}) {
     benchmarkFileExploration(files, n, rand),
     benchmarkSearch(symbols, n, rand),
     benchmarkImpactAnalysis(store, symbols, n, rand),
-    benchmarkCallGraph(store, symbols, n, rand)
+    benchmarkCallGraph(store, symbols, n, rand),
+    benchmarkTaskContext(store, symbols, files, n, rand)
   ];
   const totalQueries = scenarios.reduce((s, sc) => s + sc.queries, 0);
   const totalBaseline = scenarios.reduce((s, sc) => s + sc.baseline_tokens, 0);
@@ -21712,8 +22197,8 @@ function registerPrompts(server, ctx) {
 `);
       let changedFiles = [];
       try {
-        const { execSync: execSync3 } = await import("child_process");
-        const diff = execSync3(`git diff --name-only ${baseRef}...${branch}`, {
+        const { execSync: execSync4 } = await import("child_process");
+        const diff = execSync4(`git diff --name-only ${baseRef}...${branch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           timeout: 1e4
@@ -21934,8 +22419,8 @@ Analyze this project's architecture health. Identify the most critical issues an
 `);
       let changedFiles = [];
       try {
-        const { execSync: execSync3 } = await import("child_process");
-        const diff = execSync3(`git diff --name-only ${baseRef}...${branch}`, {
+        const { execSync: execSync4 } = await import("child_process");
+        const diff = execSync4(`git diff --name-only ${baseRef}...${branch}`, {
           cwd: projectRoot,
           encoding: "utf-8",
           timeout: 1e4
@@ -23072,7 +23557,7 @@ var FileWatcher = class {
 var require2 = createRequire(import.meta.url);
 var { version: PKG_VERSION } = require2("../package.json");
 function j2(value) {
-  return JSON.stringify(value);
+  return JSON.stringify(value, (_key, val) => val === null || val === void 0 ? void 0 : val);
 }
 function extractResultCount(response) {
   if (response?.isError) return 0;
@@ -23149,6 +23634,15 @@ function createServer2(store, registry, config, rootPath) {
         "- State stores \u2192 `get_state_stores` (Zustand/Redux/Pinia)",
         "- Event graph \u2192 `get_event_graph` (event emitters/listeners)",
         "",
+        "Token optimization (IMPORTANT \u2014 saves 40-85% tokens):",
+        "- **Batch multiple queries** \u2192 `batch` combines up to 10 tool calls into 1 MCP request. Use whenever you need 2+ independent queries:",
+        '  `batch({ calls: [{ tool: "get_outline", args: { path: "a.ts" } }, { tool: "get_outline", args: { path: "b.ts" } }] })`',
+        "- **Bundle symbol + imports** \u2192 `get_context_bundle` returns a symbol's source + its import dependencies in one call (supports batch via `symbol_ids[]`)",
+        "- **Avoid repeated file reads** \u2192 use `get_outline` once to understand structure, then `get_symbol` for specific symbols. NEVER read the same file multiple times.",
+        "- **Use `get_task_context` instead of Agent subagents** \u2192 it returns focused context within a token budget, replacing manual search chains",
+        "- Check token waste \u2192 `get_optimization_report` detects repeated reads, Bash grep, and unused trace-mcp tools",
+        "- Track savings \u2192 `get_session_stats` shows per-tool token savings; `get_real_savings` shows actual vs achievable token usage",
+        "",
         "WHEN TO USE native tools (Read/Grep/Glob):",
         "- Non-code files (.md, .json, .yaml, .toml, config) \u2192 Read/Grep",
         "- Reading a file before editing (Edit needs full content) \u2192 Read",
@@ -23171,6 +23665,7 @@ function createServer2(store, registry, config, rootPath) {
   }
   const _originalTool = server.tool.bind(server);
   const registeredToolNames = [];
+  const toolHandlers = /* @__PURE__ */ new Map();
   const descriptionOverrides = config.tools?.descriptions ?? {};
   const sharedParamOverrides = typeof descriptionOverrides._shared === "object" && descriptionOverrides._shared !== null ? descriptionOverrides._shared : {};
   server.tool = ((...args) => {
@@ -23202,6 +23697,9 @@ function createServer2(store, registry, config, rootPath) {
     const cbIdx = args.length - 1;
     const originalCb = args[cbIdx];
     if (typeof originalCb === "function") {
+      toolHandlers.set(name, async (params) => {
+        return await originalCb(params);
+      });
       args[cbIdx] = async (...cbArgs) => {
         savings.recordCall(name);
         const params = cbArgs[0] && typeof cbArgs[0] === "object" ? cbArgs[0] : {};
@@ -23238,10 +23736,12 @@ function createServer2(store, registry, config, rootPath) {
   process.on("SIGINT", flushSavings);
   process.on("SIGTERM", flushSavings);
   process.on("exit", flushSavings);
+  let budgetWarningShown = false;
   function jh(toolName, value) {
     const hinted = withHints(toolName, value);
     const stats = savings.getSessionStats();
-    if (stats.total_calls >= 15) {
+    if (stats.total_calls >= 15 && !budgetWarningShown) {
+      budgetWarningShown = true;
       const obj = hinted !== null && typeof hinted === "object" && !Array.isArray(hinted) ? hinted : { data: hinted };
       obj._budget_warning = `${stats.total_calls} tool calls this session (~${stats.total_raw_tokens} raw tokens). Consider using get_task_context or get_feature_context for consolidated context instead of many small queries.`;
       return j2(obj);
@@ -23453,13 +23953,27 @@ function createServer2(store, registry, config, rootPath) {
       }));
       const response = { items, total: result.total, search_mode: result.search_mode };
       if (items.length === 0) {
-        const stats = store.getStats();
-        response.evidence = buildNegativeEvidence(
-          stats.totalFiles,
-          stats.totalSymbols,
-          result.search_mode === "fuzzy" || !!fuzzy,
-          "search"
-        );
+        const textResult = searchText(store, projectRoot, {
+          query,
+          filePattern: file_pattern,
+          language,
+          maxResults: Math.min(limit ?? 20, 10),
+          contextLines: 1
+        });
+        if (textResult.isOk() && textResult.value.matches.length > 0) {
+          const tv = textResult.value;
+          response.fallback_text_matches = tv.matches;
+          response.fallback_total = tv.total_matches;
+          response.search_mode = "symbol_miss_text_fallback";
+        } else {
+          const stats = store.getStats();
+          response.evidence = buildNegativeEvidence(
+            stats.totalFiles,
+            stats.totalSymbols,
+            result.search_mode === "fuzzy" || !!fuzzy,
+            "search"
+          );
+        }
       }
       return { content: [{ type: "text", text: jh("search", response) }] };
     }
@@ -23482,23 +23996,25 @@ function createServer2(store, registry, config, rootPath) {
   );
   server.tool(
     "get_change_impact",
-    "Determine what depends on a file or symbol (reverse dependency analysis). Use before making changes to understand blast radius.",
+    "Full change impact report: risk score + mitigations, breaking change detection, enriched dependents (complexity, coverage, exports), module groups, affected tests, co-change hidden couplings. Supports diff-aware mode via symbol_ids to scope analysis to only changed symbols.",
     {
       file_path: z4.string().max(512).optional().describe("Relative file path to analyze"),
       symbol_id: z4.string().max(512).optional().describe("Symbol ID to analyze"),
+      symbol_ids: z4.array(z4.string().max(512)).max(50).optional().describe("Diff-aware: only analyze impact of these specific symbols (e.g. from get_changed_symbols)"),
       depth: z4.number().int().min(1).max(20).optional().describe("Max traversal depth (default 3)"),
       max_dependents: z4.number().int().min(1).max(5e3).optional().describe("Cap on returned dependents (default 200)")
     },
-    async ({ file_path, symbol_id, depth, max_dependents }) => {
+    async ({ file_path, symbol_id, symbol_ids, depth, max_dependents }) => {
       if (file_path) {
         const blocked = guardPath(file_path);
         if (blocked) return blocked;
       }
       const result = getChangeImpact(
         store,
-        { filePath: file_path, symbolId: symbol_id },
+        { filePath: file_path, symbolId: symbol_id, symbolIds: symbol_ids },
         depth ?? 3,
-        max_dependents ?? 200
+        max_dependents ?? 200,
+        projectRoot
       );
       if (result.isErr()) {
         return { content: [{ type: "text", text: j2(formatToolError(result.error)) }], isError: true };
@@ -24830,7 +25346,7 @@ function createServer2(store, registry, config, rootPath) {
       file_pattern: z4.string().max(512).optional().describe('Glob filter, e.g. "src/**/*.ts"'),
       language: z4.string().max(64).optional().describe('Filter by language (e.g. "typescript", "python")'),
       max_results: z4.number().int().min(1).max(200).optional().describe("Max matches to return (default 50)"),
-      context_lines: z4.number().int().min(0).max(10).optional().describe("Lines of context before/after each match (default 2)"),
+      context_lines: z4.number().int().min(0).max(10).optional().describe("Lines of context before/after each match (default 0 \u2014 set higher if you need surrounding code)"),
       case_sensitive: z4.boolean().optional().describe("Case-sensitive search (default false)")
     },
     async ({ query, is_regex, file_pattern, language, max_results, context_lines, case_sensitive }) => {
@@ -25436,6 +25952,43 @@ function createServer2(store, registry, config, rootPath) {
       return { content: [{ type: "text", text: j2(summary) }] };
     }
   );
+  _originalTool(
+    "batch",
+    "Execute multiple trace-mcp tools in a single MCP request. Returns results for all calls. Use to reduce round-trips when you need several independent queries (e.g., get_outline for 3 files, or search + get_symbol together).",
+    {
+      calls: z4.array(z4.object({
+        tool: z4.string().describe('Tool name (e.g., "get_outline", "get_symbol", "search")'),
+        args: z4.record(z4.unknown()).describe("Tool arguments")
+      })).min(1).max(10).describe("Array of tool calls to execute (max 10)")
+    },
+    async ({ calls }) => {
+      const results = [];
+      for (const call of calls) {
+        const handler = toolHandlers.get(call.tool);
+        if (!handler) {
+          results.push({ tool: call.tool, error: `Unknown tool: ${call.tool}` });
+          continue;
+        }
+        try {
+          savings.recordCall(call.tool);
+          const response = await handler(call.args);
+          const text = response.content?.[0]?.text;
+          if (text) {
+            try {
+              results.push({ tool: call.tool, result: JSON.parse(text) });
+            } catch {
+              results.push({ tool: call.tool, result: text });
+            }
+          } else {
+            results.push({ tool: call.tool, result: response });
+          }
+        } catch (e) {
+          results.push({ tool: call.tool, error: e instanceof Error ? e.message : String(e) });
+        }
+      }
+      return { content: [{ type: "text", text: j2({ batch_results: results, total: results.length }) }] };
+    }
+  );
   registerPrompts(server, { store, registry, config, projectRoot });
   return server;
 }