@ctxo/cli 0.7.2 → 0.8.0

package/dist/index.js

@@ -1,23 +1,29 @@
 #!/usr/bin/env node
 import {
   ArchitecturalOverlay,
+  BoundaryViolationDetector,
   DeadCodeDetector,
+  DriftDetector,
   PageRankCalculator,
   RevertDetector,
   SessionRecorderAdapter,
   SimpleGitAdapter,
   SqliteStorageAdapter,
   SymbolGraph,
-  createLogger,
   detectWorkspace,
   loadCoChangeMap,
   loadConfig,
+  makeGlobMatcher,
+  maskingClusterLabelPatterns,
   statsEnabled
-} from "./chunk-4M4V5V36.js";
+} from "./chunk-HXEPS2XY.js";
+import {
+  createLogger
+} from "./chunk-6EKERTJ7.js";
 import {
   DetailLevelSchema,
   JsonIndexReader
-} from "./chunk-WXA2JJLH.js";
+} from "./chunk-2TVHKCCU.js";
 
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -301,7 +307,9 @@ var TRUNCATABLE_FIELDS = {
   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."
+  files: "Use get_changed_symbols with a narrower since ref or smaller maxFiles.",
+  clusters: "Use get_architectural_overlay with mode=communities and layer filter for a focused view.",
+  clustersAffected: "Use get_blast_radius on individual changed symbols for per-cluster impact."
 };
 function getThreshold() {
   const env = process.env["CTXO_RESPONSE_LIMIT"];
@@ -322,10 +330,14 @@ function findTruncatableArray(data) {
   }
   return best;
 }
-function buildMeta(base) {
-  return workspaceMeta ? { ...base, workspace: workspaceMeta } : base;
+function buildMeta(base, extras) {
+  const meta = workspaceMeta ? { ...base, workspace: workspaceMeta } : base;
+  if (extras?.snapshotStaleness) {
+    return { ...meta, snapshotStaleness: extras.snapshotStaleness };
+  }
+  return meta;
 }
-function wrapResponse(data) {
+function wrapResponse(data, extras) {
   const threshold = getThreshold();
   const fullJson = JSON.stringify(data);
   const totalBytes = Buffer.byteLength(fullJson, "utf-8");
@@ -334,23 +346,29 @@ function wrapResponse(data) {
   if (totalBytes <= threshold) {
     return {
       ...data,
-      _meta: buildMeta({
-        totalItems,
-        returnedItems: totalItems,
-        truncated: false,
-        totalBytes
-      })
+      _meta: buildMeta(
+        {
+          totalItems,
+          returnedItems: totalItems,
+          truncated: false,
+          totalBytes
+        },
+        extras
+      )
     };
   }
   if (!truncatable || truncatable.arr.length <= 1) {
     return {
       ...data,
-      _meta: buildMeta({
-        totalItems,
-        returnedItems: totalItems,
-        truncated: false,
-        totalBytes
-      })
+      _meta: buildMeta(
+        {
+          totalItems,
+          returnedItems: totalItems,
+          truncated: false,
+          totalBytes
+        },
+        extras
+      )
     };
   }
   let lo = 1;
@@ -360,13 +378,16 @@ function wrapResponse(data) {
     const trial = {
       ...data,
       [truncatable.key]: truncatable.arr.slice(0, mid),
-      _meta: buildMeta({
-        totalItems,
-        returnedItems: mid,
-        truncated: true,
-        totalBytes,
-        hint: TRUNCATABLE_FIELDS[truncatable.key]
-      })
+      _meta: buildMeta(
+        {
+          totalItems,
+          returnedItems: mid,
+          truncated: true,
+          totalBytes,
+          hint: TRUNCATABLE_FIELDS[truncatable.key]
+        },
+        extras
+      )
     };
     const size = Buffer.byteLength(JSON.stringify(trial), "utf-8");
     if (size <= threshold) {
@@ -379,13 +400,16 @@ function wrapResponse(data) {
   return {
     ...data,
     [truncatable.key]: truncatable.arr.slice(0, lo),
-    _meta: buildMeta({
-      totalItems,
-      returnedItems: lo,
-      truncated: true,
-      totalBytes,
-      hint
-    })
+    _meta: buildMeta(
+      {
+        totalItems,
+        returnedItems: lo,
+        truncated: true,
+        totalBytes,
+        hint
+      },
+      extras
+    )
   };
 }
 
@@ -517,13 +541,54 @@ function handleGetLogicSlice(storage, masking, staleness, ctxoRoot = ".ctxo") {
 
 // src/adapters/mcp/get-why-context.ts
 import { z as z2 } from "zod";
+
+// src/core/overlay/snapshot-staleness.ts
+async function buildSnapshotStaleness(storage, git) {
+  const snapshot = storage.readCommunities();
+  if (!snapshot || !snapshot.commitSha || snapshot.commitSha === "nocommit") return void 0;
+  const getHead = git.getHeadSha?.bind(git);
+  const countBetween = git.countCommitsBetween?.bind(git);
+  const head = getHead ? await getHead() : void 0;
+  if (!head) {
+    return { snapshotCommit: snapshot.commitSha };
+  }
+  if (head === snapshot.commitSha) {
+    return {
+      snapshotCommit: snapshot.commitSha,
+      currentHeadCommit: head,
+      commitsBehind: 0
+    };
+  }
+  const behind = countBetween ? await countBetween(snapshot.commitSha) : void 0;
+  const result = {
+    snapshotCommit: snapshot.commitSha,
+    currentHeadCommit: head,
+    ...typeof behind === "number" ? { commitsBehind: behind } : {}
+  };
+  if (typeof behind === "number" && behind > 0) {
+    return {
+      ...result,
+      hint: `Community snapshot is ${behind} commit${behind === 1 ? "" : "s"} behind HEAD. Run \`ctxo index\` to refresh cluster / drift / boundary data.`
+    };
+  }
+  if (behind === void 0) {
+    return {
+      ...result,
+      hint: "Snapshot commit is not reachable from HEAD \u2014 it may have been rebased away. Run `ctxo index` to re-anchor."
+    };
+  }
+  return result;
+}
+
+// src/adapters/mcp/get-why-context.ts
 var InputSchema2 = z2.object({
   symbolId: z2.string().min(1),
   maxCommits: z2.number().int().min(1).optional()
 });
-function handleGetWhyContext(storage, git, masking, staleness, ctxoRoot = ".ctxo") {
+function handleGetWhyContext(storage, git, masking, staleness, ctxoRoot = ".ctxo", clusterLabelMasker) {
   const revertDetector = new RevertDetector();
   const indexReader = new JsonIndexReader(ctxoRoot);
+  const driftDetector = new DriftDetector();
   return async (args) => {
     try {
       const parsed = InputSchema2.safeParse(args);
@@ -565,6 +630,26 @@ function handleGetWhyContext(storage, git, masking, staleness, ctxoRoot = ".ctxo
       if (antiPatterns.length > 0) {
         responsePayload.warningBadge = "\u26A0 Anti-pattern detected";
       }
+      const rawSnapshot = storage.readCommunities();
+      const currentSnapshot = rawSnapshot && clusterLabelMasker?.isEnabled() ? clusterLabelMasker.maskSnapshot(rawSnapshot) : rawSnapshot;
+      if (currentSnapshot) {
+        const history = storage.listCommunityHistory();
+        const drift = driftDetector.detect(currentSnapshot, history);
+        const relevant = drift.events.filter((event) => event.symbolId === symbolId);
+        if (relevant.length > 0 || drift.hint) {
+          responsePayload.driftSignals = {
+            events: relevant,
+            confidence: drift.confidence,
+            snapshotsAvailable: drift.snapshotsAvailable,
+            stabilitySummary: drift.stability,
+            ...drift.hint ? { hint: drift.hint } : {}
+          };
+        }
+      }
+      const stalenessMeta = await buildSnapshotStaleness(storage, git);
+      if (stalenessMeta) {
+        responsePayload._meta = { snapshotStaleness: stalenessMeta };
+      }
       const payload = masking.mask(JSON.stringify(responsePayload));
       const content = [];
       if (staleness) {
@@ -763,15 +848,35 @@ var BlastRadiusCalculator = class {
 };
 
 // src/adapters/mcp/get-blast-radius.ts
+function computeClusterBreakdown(snapshot, rootSymbolId, impactedSymbolIds) {
+  if (impactedSymbolIds.length === 0) return void 0;
+  const assignment = /* @__PURE__ */ new Map();
+  for (const entry of snapshot.communities) {
+    assignment.set(entry.symbolId, { id: entry.communityId, label: entry.communityLabel });
+  }
+  const rootCluster = assignment.get(rootSymbolId);
+  const byCluster = {};
+  let crossClusterCount = 0;
+  for (const symbolId of impactedSymbolIds) {
+    const cluster = assignment.get(symbolId);
+    if (!cluster) continue;
+    const label = cluster.label || `community-${cluster.id}`;
+    byCluster[label] = (byCluster[label] ?? 0) + 1;
+    if (rootCluster && cluster.id !== rootCluster.id) crossClusterCount++;
+  }
+  const clusterCount = Object.keys(byCluster).length;
+  const multiClusterHint = clusterCount >= 3 ? `Change impacts ${clusterCount} clusters \u2014 multi-team review recommended.` : void 0;
+  return { byCluster, crossClusterCount, multiClusterHint };
+}
 var InputSchema4 = z4.object({
   symbolId: z4.string().min(1),
   confidence: z4.enum(["confirmed", "likely", "potential"]).optional(),
   intent: z4.string().optional().describe('Filter results by intent keywords (e.g., "test", "adapter", "security")')
 });
-function handleGetBlastRadius(storage, masking, staleness, ctxoRoot = ".ctxo") {
+function handleGetBlastRadius(storage, masking, staleness, ctxoRoot = ".ctxo", git, clusterLabelMasker) {
   const calculator = new BlastRadiusCalculator();
   const getGraph = () => getGraphAndFiles(ctxoRoot, storage);
-  return (args) => {
+  return async (args) => {
     try {
       const parsed = InputSchema4.safeParse(args);
       if (!parsed.success) {
@@ -795,7 +900,10 @@ function handleGetBlastRadius(storage, masking, staleness, ctxoRoot = ".ctxo") {
       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({
+      const rawSnapshot = storage.readCommunities();
+      const snapshot = rawSnapshot && clusterLabelMasker?.isEnabled() ? clusterLabelMasker.maskSnapshot(rawSnapshot) : rawSnapshot;
+      const clusterBreakdown = snapshot ? computeClusterBreakdown(snapshot, symbolId, symbols.map((s) => s.symbolId)) : void 0;
+      const body = {
         symbolId,
         impactScore: symbols.length,
         directDependentsCount: result.directDependentsCount,
@@ -804,7 +912,17 @@ function handleGetBlastRadius(storage, masking, staleness, ctxoRoot = ".ctxo") {
         potentialCount,
         overallRiskScore: result.overallRiskScore,
         impactedSymbols: symbols
-      })));
+      };
+      if (clusterBreakdown) {
+        body.byCluster = clusterBreakdown.byCluster;
+        body.crossClusterEdges = clusterBreakdown.crossClusterCount;
+        if (clusterBreakdown.multiClusterHint) {
+          body.multiClusterHint = clusterBreakdown.multiClusterHint;
+        }
+      }
+      const stalenessMeta = git ? await buildSnapshotStaleness(storage, git) : void 0;
+      const extras = stalenessMeta ? { snapshotStaleness: stalenessMeta } : void 0;
+      const payload = masking.mask(JSON.stringify(wrapResponse(body, extras)));
       const content = [];
       if (staleness) {
         const warning = staleness.check(indexedFiles);
@@ -822,12 +940,57 @@ function handleGetBlastRadius(storage, masking, staleness, ctxoRoot = ".ctxo") {
 
 // src/adapters/mcp/get-architectural-overlay.ts
 import { z as z5 } from "zod";
+var OVERLAY_MODES = ["regex", "communities", "both"];
 var InputSchema5 = z5.object({
-  layer: z5.string().optional()
+  layer: z5.string().optional(),
+  mode: z5.enum(OVERLAY_MODES).optional()
 });
-function handleGetArchitecturalOverlay(storage, masking, staleness) {
+function buildCommunityOverlay(snapshot, options = {}) {
+  const previewLimit = options.memberPreviewLimit ?? 15;
+  const byCluster = /* @__PURE__ */ new Map();
+  for (const entry of snapshot.communities) {
+    const list = byCluster.get(entry.communityId) ?? [];
+    list.push(entry.symbolId);
+    byCluster.set(entry.communityId, list);
+  }
+  const labelFor = /* @__PURE__ */ new Map();
+  for (const entry of snapshot.communities) {
+    if (!labelFor.has(entry.communityId)) {
+      labelFor.set(entry.communityId, entry.communityLabel);
+    }
+  }
+  const godNodesByCommunity = /* @__PURE__ */ new Map();
+  for (const god of snapshot.godNodes) {
+    for (const communityId of god.bridgedCommunities) {
+      const set = godNodesByCommunity.get(communityId) ?? /* @__PURE__ */ new Set();
+      set.add(god.symbolId);
+      godNodesByCommunity.set(communityId, set);
+    }
+  }
+  const clusters = [];
+  for (const [id, members] of byCluster) {
+    members.sort();
+    clusters.push({
+      id,
+      label: labelFor.get(id) ?? `community-${id}`,
+      memberCount: members.length,
+      members: members.slice(0, previewLimit),
+      godNodes: [...godNodesByCommunity.get(id) ?? []].sort()
+    });
+  }
+  clusters.sort((a, b) => b.memberCount - a.memberCount || a.id - b.id);
+  return {
+    clusters,
+    modularity: snapshot.modularity,
+    edgeQuality: snapshot.edgeQuality,
+    crossClusterEdges: snapshot.crossClusterEdges,
+    computedAt: snapshot.computedAt,
+    commitSha: snapshot.commitSha
+  };
+}
+function handleGetArchitecturalOverlay(storage, masking, staleness, git, clusterLabelMasker) {
   const overlay = new ArchitecturalOverlay();
-  return (args) => {
+  return async (args) => {
     try {
       const parsed = InputSchema5.safeParse(args);
       if (!parsed.success) {
@@ -837,6 +1000,7 @@ function handleGetArchitecturalOverlay(storage, masking, staleness) {
       }
       const files = storage.listIndexedFiles();
       const result = overlay.classify(files);
+      const mode = parsed.data.mode ?? "both";
       const buildContent = (payloadStr) => {
         const content = [];
         if (staleness) {
@@ -846,12 +1010,25 @@ function handleGetArchitecturalOverlay(storage, masking, staleness) {
         content.push({ type: "text", text: payloadStr });
         return content;
       };
+      const stalenessMeta = git ? await buildSnapshotStaleness(storage, git) : void 0;
+      const extras = stalenessMeta ? { snapshotStaleness: stalenessMeta } : void 0;
       if (parsed.data.layer) {
         const filtered = result.layers[parsed.data.layer];
-        const payload2 = masking.mask(JSON.stringify({ layer: parsed.data.layer, files: filtered ?? [] }));
+        const payload2 = masking.mask(
+          JSON.stringify(wrapResponse({ layer: parsed.data.layer, files: filtered ?? [] }, extras))
+        );
         return { content: buildContent(payload2) };
       }
-      const payload = masking.mask(JSON.stringify(result));
+      const rawSnapshot = mode === "regex" ? void 0 : storage.readCommunities();
+      const snapshot = rawSnapshot && clusterLabelMasker?.isEnabled() ? clusterLabelMasker.maskSnapshot(rawSnapshot) : rawSnapshot;
+      const community = snapshot ? buildCommunityOverlay(snapshot) : void 0;
+      const body = {};
+      if (mode !== "communities") body.layers = result.layers;
+      if (community) body.communities = community;
+      if (mode === "communities" && !community) {
+        body.hint = "No community snapshot available. Run `ctxo index` to generate one.";
+      }
+      const payload = masking.mask(JSON.stringify(wrapResponse(body, extras)));
       return { content: buildContent(payload) };
     } catch (err) {
       return {
@@ -2294,7 +2471,20 @@ function loadCoChanges(ctxoRoot) {
     return void 0;
   }
 }
-function handleGetPrImpact(storage, git, masking, staleness, ctxoRoot = ".ctxo") {
+function computeClustersAffected(snapshot, changedSymbolIds) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const entry of snapshot.communities) {
+    if (!changedSymbolIds.has(entry.symbolId)) continue;
+    const existing = totals.get(entry.communityId);
+    if (existing) {
+      existing.count += 1;
+    } else {
+      totals.set(entry.communityId, { label: entry.communityLabel, count: 1 });
+    }
+  }
+  return [...totals.entries()].map(([id, { label, count }]) => ({ id, label, symbolCount: count })).sort((a, b) => b.symbolCount - a.symbolCount || a.id - b.id);
+}
+function handleGetPrImpact(storage, git, masking, staleness, ctxoRoot = ".ctxo", clusterLabelMasker) {
   const calculator = new BlastRadiusCalculator();
   const getGraph = () => getGraphAndFiles(ctxoRoot, storage);
   return async (args) => {
@@ -2387,7 +2577,30 @@ function handleGetPrImpact(storage, git, masking, staleness, ctxoRoot = ".ctxo")
       }, 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({
+      const rawSnapshot = storage.readCommunities();
+      const snapshot = rawSnapshot && clusterLabelMasker?.isEnabled() ? clusterLabelMasker.maskSnapshot(rawSnapshot) : rawSnapshot;
+      const history = snapshot ? storage.listCommunityHistory() : [];
+      let boundarySection;
+      let clustersAffected;
+      if (snapshot) {
+        const detector = new BoundaryViolationDetector();
+        const violationResult = detector.detect(graph, snapshot, history);
+        const changedSymbolIds = /* @__PURE__ */ new Set();
+        for (const file of files) {
+          for (const sym of file.symbols) changedSymbolIds.add(sym.symbolId);
+        }
+        const relevant = violationResult.violations.filter(
+          (v) => changedSymbolIds.has(v.from.symbolId) || changedSymbolIds.has(v.to.symbolId)
+        );
+        boundarySection = {
+          violations: relevant,
+          confidence: violationResult.confidence,
+          snapshotsAvailable: violationResult.snapshotsAvailable,
+          ...violationResult.hint ? { hint: violationResult.hint } : {}
+        };
+        clustersAffected = computeClustersAffected(snapshot, changedSymbolIds);
+      }
+      const body = {
         since,
         changedFiles: files.length,
         changedSymbols,
@@ -2400,7 +2613,12 @@ function handleGetPrImpact(storage, git, masking, staleness, ctxoRoot = ".ctxo")
           potentialTotal,
           highRiskSymbols: highRiskSymbols.slice(0, 10)
         }
-      })));
+      };
+      if (boundarySection) body.boundaryViolations = boundarySection;
+      if (clustersAffected && clustersAffected.length > 0) body.clustersAffected = clustersAffected;
+      const stalenessMeta = await buildSnapshotStaleness(storage, git);
+      const extras = stalenessMeta ? { snapshotStaleness: stalenessMeta } : void 0;
+      const payload = masking.mask(JSON.stringify(wrapResponse(body, extras)));
       const content = [];
       if (staleness) {
         const warning = staleness.check(indexedFiles);
@@ -2462,6 +2680,40 @@ function recordEvent(toolName, args, result, latencyMs, recorder) {
   }
 }
 
+// src/core/overlay/cluster-label-masker.ts
+var ClusterLabelMasker = class {
+  matcher;
+  enabled;
+  labelCache = /* @__PURE__ */ new Map();
+  constructor(patterns) {
+    this.enabled = patterns.length > 0;
+    this.matcher = this.enabled ? makeGlobMatcher([...patterns]) : () => false;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  mask(label) {
+    if (!this.enabled) return label;
+    if (!this.matcher(label)) return label;
+    const cached = this.labelCache.get(label);
+    if (cached) return cached;
+    const masked = `[masked-cluster-${this.labelCache.size + 1}]`;
+    this.labelCache.set(label, masked);
+    return masked;
+  }
+  maskSnapshot(snapshot) {
+    if (!this.enabled) return snapshot;
+    const uniqueLabels = [...new Set(snapshot.communities.map((c) => c.communityLabel))].sort();
+    for (const label of uniqueLabels) this.mask(label);
+    const maskedCommunities = snapshot.communities.map((entry) => ({
+      ...entry,
+      communityLabel: this.mask(entry.communityLabel)
+    }));
+    const maskedGodNodes = snapshot.godNodes.map((g) => ({ ...g }));
+    return { ...snapshot, communities: maskedCommunities, godNodes: maskedGodNodes };
+  }
+};
+
 // src/index.ts
 var log4 = createLogger("ctxo:mcp");
 function loadMaskingConfig(ctxoRoot) {
@@ -2495,7 +2747,7 @@ async function main() {
   const args = process.argv.slice(2);
   const httpPortStr = process.env.CTXO_HTTP_PORT || (args.includes("--http") ? args[args.indexOf("--port") + 1] || "3001" : null);
   if (!httpPortStr && args.length > 0) {
-    const { CliRouter } = await import("./cli-router-T3VZZJD6.js");
+    const { CliRouter } = await import("./cli-router-GZA44VOV.js");
     const router = new CliRouter(process.cwd());
     await router.route(args);
     return;
@@ -2503,19 +2755,22 @@ async function main() {
   const ctxoRoot = ".ctxo";
   const workspace = detectWorkspace(process.cwd());
   setWorkspaceMeta({ root: workspace.root });
-  const storage = new SqliteStorageAdapter(ctxoRoot);
+  const storage = new SqliteStorageAdapter(ctxoRoot, { allowProductionPath: true });
   await storage.init();
   const masking = loadMaskingConfig(ctxoRoot);
+  const clusterLabelMasker = new ClusterLabelMasker(
+    maskingClusterLabelPatterns(loadConfig(ctxoRoot).config)
+  );
   const git = new SimpleGitAdapter(process.cwd());
   const recorder = readStatsEnabled(ctxoRoot) ? new SessionRecorderAdapter(storage.getDb(), () => storage.persist()) : null;
   const server = new McpServer({ name: "ctxo", version: PKG_VERSION });
   const { StalenessDetector } = await import("./staleness-detector-4HJYBQ7Z.js");
   const staleness = new StalenessDetector(process.cwd(), ctxoRoot);
-  registerTools(server, storage, masking, git, staleness, recorder, ctxoRoot);
+  registerTools(server, storage, masking, git, staleness, recorder, ctxoRoot, clusterLabelMasker);
   if (httpPortStr) {
     await startHttpTransport(async () => {
       const s = new McpServer({ name: "ctxo", version: PKG_VERSION });
-      registerTools(s, storage, masking, git, staleness, recorder, ctxoRoot);
+      registerTools(s, storage, masking, git, staleness, recorder, ctxoRoot, clusterLabelMasker);
       return s;
     }, parseInt(httpPortStr, 10));
   } else {
@@ -2523,7 +2778,7 @@ async function main() {
     await server.connect(transport);
   }
 }
-function registerTools(server, storage, masking, git, staleness, recorder, ctxoRoot = ".ctxo") {
+function registerTools(server, storage, masking, git, staleness, recorder, ctxoRoot = ".ctxo", clusterLabelMasker) {
   const toolAnnotations = {
     readOnlyHint: true,
     destructiveHint: false,
@@ -2531,7 +2786,7 @@ function registerTools(server, storage, masking, git, staleness, recorder, ctxoR
     openWorldHint: false
   };
   const logicSliceHandler = withRecording("get_logic_slice", handleGetLogicSlice(storage, masking, staleness, ctxoRoot), recorder);
-  const whyContextHandler = withRecording("get_why_context", handleGetWhyContext(storage, git, masking, staleness, ctxoRoot), recorder);
+  const whyContextHandler = withRecording("get_why_context", handleGetWhyContext(storage, git, masking, staleness, ctxoRoot, clusterLabelMasker), recorder);
   const changeIntelligenceHandler = withRecording("get_change_intelligence", handleGetChangeIntelligence(storage, git, masking, staleness, ctxoRoot), recorder);
   server.registerTool(
     "get_logic_slice",
@@ -2570,7 +2825,7 @@ function registerTools(server, storage, masking, git, staleness, recorder, ctxoR
     },
     (args) => changeIntelligenceHandler(args)
   );
-  const blastRadiusHandler = withRecording("get_blast_radius", handleGetBlastRadius(storage, masking, staleness, ctxoRoot), recorder);
+  const blastRadiusHandler = withRecording("get_blast_radius", handleGetBlastRadius(storage, masking, staleness, ctxoRoot, git, clusterLabelMasker), recorder);
   server.registerTool(
     "get_blast_radius",
     {
@@ -2584,7 +2839,7 @@ function registerTools(server, storage, masking, git, staleness, recorder, ctxoR
     },
     (args) => blastRadiusHandler(args)
   );
-  const overlayHandler = withRecording("get_architectural_overlay", handleGetArchitecturalOverlay(storage, masking, staleness), recorder);
+  const overlayHandler = withRecording("get_architectural_overlay", handleGetArchitecturalOverlay(storage, masking, staleness, git, clusterLabelMasker), recorder);
   server.registerTool(
     "get_architectural_overlay",
     {
@@ -2709,7 +2964,7 @@ function registerTools(server, storage, masking, git, staleness, recorder, ctxoR
     },
     (args) => symbolImportanceHandler(args)
   );
-  const prImpactHandler = withRecording("get_pr_impact", handleGetPrImpact(storage, git, masking, staleness, ctxoRoot), recorder);
+  const prImpactHandler = withRecording("get_pr_impact", handleGetPrImpact(storage, git, masking, staleness, ctxoRoot, clusterLabelMasker), recorder);
   server.registerTool(
     "get_pr_impact",
     {