vibe-splain 2.5.0 → 2.7.0

package/dist/index.js

@@ -19,8 +19,9 @@ function expandPath(p) {
   return p;
 }
 var AGENT_CONFIGS = [
-  { name: "Claude Code", path: "~/.claude/claude_desktop_config.json", format: "claude" },
-  { name: "Claude Code (Windows)", path: "%APPDATA%/Claude/claude_desktop_config.json", format: "claude" },
+  { name: "Claude Code CLI", path: "~/.claude/settings.json", format: "claude" },
+  { name: "Claude Desktop", path: "~/.claude/claude_desktop_config.json", format: "claude" },
+  { name: "Claude Desktop (Windows)", path: "%APPDATA%/Claude/claude_desktop_config.json", format: "claude" },
   { name: "Gemini CLI", path: "~/.gemini/settings.json", format: "gemini" },
   { name: "Cursor", path: "~/.cursor/mcp.json", format: "cursor" },
   { name: "Windsurf", path: "~/.codeium/windsurf/mcp_config.json", format: "cursor" }
@@ -88,10 +89,10 @@ import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema
 
 // ../brain/dist/scanner.js
 import { extname as extname4 } from "path";
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile8 } from "fs/promises";
 
 // ../brain/dist/pipeline/orchestrator.js
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // ../brain/dist/graph.js
 import { join as join2 } from "path";
@@ -571,6 +572,122 @@ function extractImports(source, lang) {
     specs.push(m[1] || m[2]);
   return specs;
 }
+function extractNamedImports(source, lang, tree) {
+  const imports = [];
+  if (lang !== "typescript" && lang !== "tsx" && lang !== "javascript") {
+    return imports;
+  }
+  const walk = (node) => {
+    if (node.type === "import_statement") {
+      const moduleSpecifierNode = node.childForFieldName("source");
+      if (!moduleSpecifierNode)
+        return;
+      const moduleSpecifier = moduleSpecifierNode.text.replace(/['"]/g, "");
+      const importKeyword = node.children.find((c) => c.type === "import");
+      let isGlobalTypeOnly = false;
+      if (importKeyword) {
+        const nextNode = importKeyword.nextSibling;
+        if (nextNode && nextNode.type === "type") {
+          isGlobalTypeOnly = true;
+        }
+      }
+      const importClause = node.children.find((c) => c.type === "import_clause");
+      if (!importClause) {
+        imports.push({
+          localName: "",
+          importedName: "",
+          moduleSpecifier,
+          importKind: "side_effect",
+          isTypeOnly: isGlobalTypeOnly,
+          sourceLine: node.startPosition.row + 1,
+          rawText: firstLine(node.text)
+        });
+        return;
+      }
+      const defaultIdentifier = importClause.children.find((c) => c.type === "identifier");
+      if (defaultIdentifier) {
+        imports.push({
+          localName: defaultIdentifier.text,
+          importedName: "default",
+          moduleSpecifier,
+          importKind: "default",
+          isTypeOnly: isGlobalTypeOnly,
+          sourceLine: node.startPosition.row + 1,
+          rawText: firstLine(node.text)
+        });
+      }
+      const namespaceImport = importClause.children.find((c) => c.type === "namespace_import");
+      if (namespaceImport) {
+        const identifier = namespaceImport.children.find((c) => c.type === "identifier");
+        if (identifier) {
+          imports.push({
+            localName: identifier.text,
+            importedName: "*",
+            moduleSpecifier,
+            importKind: "namespace",
+            isTypeOnly: isGlobalTypeOnly,
+            sourceLine: node.startPosition.row + 1,
+            rawText: firstLine(node.text)
+          });
+        }
+      }
+      const namedImports = importClause.children.find((c) => c.type === "named_imports");
+      if (namedImports) {
+        for (const specifier of namedImports.children.filter((c) => c.type === "import_specifier")) {
+          const isTypeKeyword = specifier.children.some((c) => c.type === "type");
+          const isSpecifierTypeOnly = isGlobalTypeOnly || isTypeKeyword;
+          const nameNode = specifier.childForFieldName("name");
+          const aliasNode = specifier.childForFieldName("alias");
+          if (nameNode) {
+            imports.push({
+              localName: aliasNode ? aliasNode.text : nameNode.text,
+              importedName: nameNode.text,
+              moduleSpecifier,
+              importKind: "named",
+              isTypeOnly: isSpecifierTypeOnly,
+              sourceLine: node.startPosition.row + 1,
+              rawText: firstLine(node.text)
+            });
+          }
+        }
+      }
+    } else if (node.type === "variable_declarator") {
+      const init = node.childForFieldName("value");
+      if (init && init.type === "call_expression") {
+        const fnNameNode = init.childForFieldName("function");
+        if (fnNameNode && fnNameNode.text === "require") {
+          const args = init.childForFieldName("arguments");
+          if (args && args.namedChildCount > 0) {
+            const specNode = args.namedChildren[0];
+            if (specNode.type === "string") {
+              const specifier = specNode.text.replace(/['"]/g, "");
+              const idNode = node.childForFieldName("name");
+              if (idNode) {
+                if (idNode.type === "identifier") {
+                  imports.push({
+                    localName: idNode.text,
+                    importedName: "default",
+                    moduleSpecifier: specifier,
+                    importKind: "default",
+                    isTypeOnly: false,
+                    sourceLine: node.startPosition.row + 1,
+                    rawText: firstLine(node.text)
+                  });
+                } else if (idNode.type === "object_pattern") {
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    for (const child of node.children) {
+      walk(child);
+    }
+  };
+  walk(tree.rootNode);
+  return imports;
+}
 async function detectStackAndEntrypoints(projectRoot, files) {
   const stack = /* @__PURE__ */ new Set();
   const entrypoints = /* @__PURE__ */ new Set();
@@ -989,11 +1106,12 @@ function analyzeAst(source, lang, tree) {
   }
   scored.sort((a, b) => b.score - a.score);
   const hotSpans = scored.slice(0, 3).filter((s) => s.bodyLOC >= 4).map((s) => {
-    const raw = source.split("\n").slice(s.node.startPosition.row, s.node.endPosition.row + 1).join("\n");
-    const snippet = stripLeadingComments(raw).slice(0, 2e3);
+    const rawExcerpt = source.split("\n").slice(s.node.startPosition.row, s.node.endPosition.row + 1).join("\n");
+    const snippet = stripLeadingComments(rawExcerpt).slice(0, 2e3);
     return {
       startLine: s.node.startPosition.row + 1,
       endLine: s.node.endPosition.row + 1,
+      rawExcerpt,
       snippet,
       reason: `high complexity: ${s.decisions} decision branches across ${s.bodyLOC} lines`
     };
@@ -1062,6 +1180,7 @@ async function runInventory(projectRoot) {
       continue;
     const ast = analyzeAst(source, lang, tree);
     const importSpecs = extractImports(source, lang);
+    const rawNamedImports = extractNamedImports(source, lang, tree);
     const frameworkRole = inferFrameworkRole(rel);
     const productDomain = inferProductDomain(rel, importSpecs);
     work.push({
@@ -1070,7 +1189,9 @@ async function runInventory(projectRoot) {
       lang,
       source,
       ast,
+      tree,
       importSpecs,
+      rawNamedImports,
       pathDemote: pathDemoteReason(rel),
       frameworkRole,
       productDomain
@@ -2049,9 +2170,516 @@ async function runClassification(projectRoot, inv, res) {
   return { projectRoot, classified, stack: inv.stack, entrypoints, map, communities };
 }
 
-// ../brain/dist/pipeline/scoring.js
+// ../brain/dist/pipeline/binding.js
 import { join as join7 } from "path";
-import { writeFile as writeFile7, mkdir as mkdir6 } from "fs/promises";
+import { writeFile as writeFile7, readFile as readFile6 } from "fs/promises";
+var FUNCTION_TYPES2 = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "function",
+  "function_expression",
+  "arrow_function",
+  "method_definition",
+  "function_definition",
+  "method_declaration",
+  "func_literal",
+  "function_item",
+  "closure_expression",
+  "constructor_declaration",
+  "generator_function_declaration",
+  "generator_function"
+]);
+function firstLine2(s) {
+  return s.split("\n")[0].trim();
+}
+function resolveCallee(node) {
+  if (node.type === "identifier") {
+    return { root: node.text, prop: null };
+  }
+  if (node.type === "member_expression" || node.type === "property_identifier") {
+    const obj = node.childForFieldName("object");
+    const prop = node.childForFieldName("property");
+    if (obj && prop) {
+      if (obj.type === "identifier") {
+        return { root: obj.text, prop: prop.text };
+      } else {
+        const nested = resolveCallee(obj);
+        if (nested) {
+          return { root: nested.root, prop: nested.prop ? `${nested.prop}.${prop.text}` : prop.text };
+        }
+      }
+    }
+  }
+  return null;
+}
+async function runActionBinding(projectRoot, inv, res) {
+  const artifact = {
+    schemaVersion: 1,
+    projectRoot,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: {},
+    functionIndex: {},
+    actionIndex: {},
+    entrypointIndex: {}
+  };
+  let filesProcessed = 0;
+  let functionsExtracted = 0;
+  let callsExtracted = 0;
+  let callsResolved = 0;
+  let semanticActionsExtracted = 0;
+  let entrypointsFound = 0;
+  let namedImportsExtracted = 0;
+  for (const w of inv.work) {
+    if (w.pathDemote)
+      continue;
+    filesProcessed++;
+    const filePath = w.rel;
+    const imports = [];
+    for (const raw of w.rawNamedImports) {
+      namedImportsExtracted++;
+      const { resolved, isAlias } = resolveImportWithAliasMap(raw.moduleSpecifier, w.abs, w.lang, projectRoot, inv.fileSet, inv.basenameIndex, res.aliasMap);
+      let confidence = "low";
+      if (resolved)
+        confidence = "high";
+      else if (isAlias)
+        confidence = "medium";
+      imports.push({
+        localName: raw.localName,
+        importedName: raw.importedName,
+        moduleSpecifier: raw.moduleSpecifier,
+        resolvedFilePath: resolved,
+        importKind: raw.importKind,
+        isTypeOnly: raw.isTypeOnly,
+        sourceLine: raw.sourceLine,
+        confidence,
+        evidenceText: raw.rawText.slice(0, 200)
+      });
+    }
+    const functions = [];
+    if (!w.tree)
+      continue;
+    const walkNodes = (node, cb) => {
+      cb(node);
+      for (const child of node.children)
+        walkNodes(child, cb);
+    };
+    const functionNodes = [];
+    walkNodes(w.tree.rootNode, (n) => {
+      if (FUNCTION_TYPES2.has(n.type))
+        functionNodes.push(n);
+    });
+    for (const node of functionNodes) {
+      functionsExtracted++;
+      let displayName = "";
+      let nameSource = "position_fallback";
+      const p = node.parent;
+      const startLine = node.startPosition.row + 1;
+      const startCol = node.startPosition.column;
+      if (node.childForFieldName("name")) {
+        displayName = node.childForFieldName("name").text;
+        nameSource = node.type === "method_definition" ? "method_definition" : "function_declaration";
+      } else if (p?.type === "variable_declarator" && p.childForFieldName("name")) {
+        displayName = p.childForFieldName("name").text;
+        nameSource = "parent_variable_declarator";
+      } else if (p?.type === "assignment_expression" && p.childForFieldName("left")) {
+        displayName = p.childForFieldName("left").text;
+        nameSource = "parent_assignment";
+      } else if (p?.type === "pair" && p.childForFieldName("key")) {
+        displayName = p.childForFieldName("key").text;
+        nameSource = "object_property_key";
+      } else if (p?.type === "export_statement") {
+        const idNode = p.children.find((c) => c.type === "identifier");
+        if (idNode) {
+          displayName = idNode.text;
+          nameSource = "export_const";
+        }
+      } else if (p?.type === "lexical_declaration" || p?.type === "variable_declaration") {
+        const decl = p.children.find((c) => c.type === "variable_declarator");
+        if (decl && decl.childForFieldName("name")) {
+          displayName = decl.childForFieldName("name").text;
+          nameSource = "parent_variable_declarator";
+        }
+      }
+      if (!displayName) {
+        displayName = `anonymous@${startLine}:${startCol}`;
+        nameSource = "position_fallback";
+      }
+      const functionId = `${filePath}::${displayName}::${startLine}:${startCol}`;
+      let isExported = false;
+      if (p?.type === "export_statement")
+        isExported = true;
+      if (p?.parent?.type === "export_statement")
+        isExported = true;
+      if (w.ast.exportedNames.includes(displayName))
+        isExported = true;
+      const isEntrypoint = (w.frameworkRole.includes("route") || w.frameworkRole.includes("page")) && isExported;
+      if (isEntrypoint)
+        entrypointsFound++;
+      const fnRecord = {
+        functionId,
+        displayName,
+        nameSource,
+        functionKind: node.type,
+        filePath,
+        startLine,
+        endLine: node.endPosition.row + 1,
+        startCol,
+        isExported,
+        isEntrypoint,
+        calls: [],
+        semanticActions: [],
+        evidenceText: firstLine2(node.text).slice(0, 200)
+      };
+      functions.push(fnRecord);
+    }
+    for (const fnRecord of functions) {
+      const fnNode = functionNodes.find((n) => n.startPosition.row + 1 === fnRecord.startLine && n.startPosition.column === fnRecord.startCol);
+      if (!fnNode)
+        continue;
+      const callNodes = [];
+      walkNodes(fnNode, (n) => {
+        if (n.type === "call_expression")
+          callNodes.push(n);
+      });
+      for (const callNode of callNodes) {
+        let isNested = false;
+        let curr = callNode.parent;
+        while (curr && curr !== fnNode) {
+          if (FUNCTION_TYPES2.has(curr.type)) {
+            isNested = true;
+            break;
+          }
+          curr = curr.parent;
+        }
+        if (isNested)
+          continue;
+        callsExtracted++;
+        const calleeNode = callNode.childForFieldName("function");
+        if (!calleeNode)
+          continue;
+        let actualCalleeNode = calleeNode;
+        if (calleeNode.type === "await_expression" && calleeNode.children.length > 1) {
+          actualCalleeNode = calleeNode.children[1];
+        }
+        const resolvedCallee = resolveCallee(actualCalleeNode);
+        if (!resolvedCallee)
+          continue;
+        const { root: calleeRoot, prop: calleeProperty } = resolvedCallee;
+        const calleeText = actualCalleeNode.text.slice(0, 100);
+        const sourceLine = callNode.startPosition.row + 1;
+        const callId = `${fnRecord.functionId}::${calleeText}::${sourceLine}`;
+        let isSemantic = false;
+        let actionKind = null;
+        let targetModel = null;
+        let targetOperation = null;
+        if (calleeRoot === "prisma" && calleeProperty) {
+          if (/\.(create|update|upsert|delete|deleteMany|updateMany|createMany|executeRaw|queryRaw)$/.test("." + calleeProperty)) {
+            isSemantic = true;
+            actionKind = "database_write";
+            const parts = calleeProperty.split(".");
+            if (parts.length >= 2) {
+              targetModel = parts[0].charAt(0).toUpperCase() + parts[0].slice(1);
+              targetOperation = parts[parts.length - 1];
+            }
+          } else if (/\.(findMany|findUnique|findFirst|findFirstOrThrow|findUniqueOrThrow|count|aggregate|groupBy)$/.test("." + calleeProperty)) {
+            isSemantic = true;
+            actionKind = "database_read";
+            const parts = calleeProperty.split(".");
+            if (parts.length >= 2) {
+              targetModel = parts[0].charAt(0).toUpperCase() + parts[0].slice(1);
+              targetOperation = parts[parts.length - 1];
+            }
+          }
+        }
+        if (!isSemantic) {
+          if (calleeRoot === "fetch" || calleeRoot === "axios" && calleeProperty && /\.(get|post|put|patch|delete)$/.test("." + calleeProperty)) {
+            isSemantic = true;
+            actionKind = "external_api_call";
+          } else if (/validate|schema\.parse|schema\.safeParse|z\.parse/i.test(calleeText) || /validate|validator/i.test(calleeRoot)) {
+            isSemantic = true;
+            actionKind = "validation";
+          } else if (/getSession|getServerSession|auth\(\)|verifyToken|requireAuth|checkPermission/i.test(calleeText) || /auth|session/i.test(calleeRoot) && calleeProperty && /check|verify|get|require/i.test("." + calleeProperty)) {
+            isSemantic = true;
+            actionKind = "auth_check";
+          } else if (/sendEmail|sendMail|mailer\./i.test(calleeText)) {
+            isSemantic = true;
+            actionKind = "email_send";
+          } else if (/createCalendarEvent|updateCalendarEvent|deleteCalendarEvent|calendar\.events\.(insert|update|delete)/i.test(calleeText)) {
+            isSemantic = true;
+            actionKind = "calendar_mutation";
+          } else if (/triggerWebhook|sendWebhook|webhook\.send/i.test(calleeText)) {
+            isSemantic = true;
+            actionKind = "webhook_delivery";
+          } else if (/stripe\.webhooks\.constructEvent|validateWebhook|verifySignature/i.test(calleeText)) {
+            isSemantic = true;
+            actionKind = "webhook_ingress";
+          } else if (/revalidatePath|revalidateTag/i.test(calleeText)) {
+            isSemantic = true;
+            actionKind = "cache_revalidation";
+          } else if (/posthog\.|mixpanel\.|amplitude\.|ga\(/i.test(calleeText)) {
+            isSemantic = true;
+            actionKind = "analytics_event";
+          } else if (calleeRoot === "redirect" || /router|redirect|notFound|permanentRedirect/.test(calleeRoot) && calleeProperty && /push|replace|back/i.test("." + calleeProperty)) {
+            isSemantic = true;
+            actionKind = "redirect";
+          } else {
+            const emailImport = imports.find((i) => i.localName === calleeRoot && /nodemailer|resend|sendgrid|postmark|mailgun/i.test(i.moduleSpecifier));
+            if (emailImport) {
+              isSemantic = true;
+              actionKind = "email_send";
+            }
+          }
+        }
+        if (isSemantic && actionKind) {
+          semanticActionsExtracted++;
+          const actionId = `${fnRecord.functionId}::${actionKind}::${sourceLine}`;
+          fnRecord.semanticActions.push({
+            actionId,
+            sourceFunctionId: fnRecord.functionId,
+            actionKind,
+            targetModel,
+            targetOperation,
+            calleeText,
+            sourceLine,
+            confidence: "high",
+            evidenceText: firstLine2(callNode.text).slice(0, 200)
+          });
+          if (!artifact.actionIndex[actionKind])
+            artifact.actionIndex[actionKind] = [];
+          artifact.actionIndex[actionKind].push(fnRecord.functionId);
+          if (targetModel) {
+            const key1 = `${actionKind}::${targetModel}`;
+            if (!artifact.actionIndex[key1])
+              artifact.actionIndex[key1] = [];
+            artifact.actionIndex[key1].push(fnRecord.functionId);
+            if (targetOperation) {
+              const key2 = `${actionKind}::${targetModel}::${targetOperation}`;
+              if (!artifact.actionIndex[key2])
+                artifact.actionIndex[key2] = [];
+              artifact.actionIndex[key2].push(fnRecord.functionId);
+            }
+          }
+        } else {
+          let resolvedTargetFunctionId = null;
+          let resolvedFilePath = null;
+          let resolutionKind = "unresolved";
+          let confidence = "unresolved";
+          const sameFileFn = functions.find((f) => f.displayName === calleeRoot);
+          if (sameFileFn) {
+            resolvedTargetFunctionId = sameFileFn.functionId;
+            resolutionKind = "same_file_function";
+            confidence = "high";
+          } else {
+            const namedImp = imports.find((i) => i.localName === calleeRoot && i.importKind !== "namespace" && !i.isTypeOnly);
+            if (namedImp && namedImp.resolvedFilePath) {
+              resolvedFilePath = namedImp.resolvedFilePath;
+              resolutionKind = "named_import_match";
+              confidence = "high";
+            } else {
+              const nsImp = imports.find((i) => i.localName === calleeRoot && i.importKind === "namespace");
+              if (nsImp && nsImp.resolvedFilePath) {
+                resolvedFilePath = nsImp.resolvedFilePath;
+                resolutionKind = "namespace_import_property";
+                confidence = "medium";
+              }
+            }
+          }
+          if (resolutionKind !== "unresolved")
+            callsResolved++;
+          fnRecord.calls.push({
+            callId,
+            sourceFunctionId: fnRecord.functionId,
+            calleeText,
+            calleeRoot,
+            calleeProperty,
+            sourceLine,
+            sourceSpan: { startLine: callNode.startPosition.row + 1, endLine: callNode.endPosition.row + 1 },
+            resolvedTargetFunctionId,
+            resolvedFilePath,
+            resolutionKind,
+            confidence,
+            evidenceText: firstLine2(callNode.text).slice(0, 200)
+          });
+        }
+      }
+    }
+    artifact.files[filePath] = {
+      filePath,
+      language: w.lang,
+      sourceRole: w.frameworkRole === "test" ? "test" : "production",
+      imports,
+      functions
+    };
+    for (const fn of functions) {
+      artifact.functionIndex[fn.functionId] = {
+        filePath,
+        displayName: fn.displayName,
+        startLine: fn.startLine,
+        endLine: fn.endLine
+      };
+      if (fn.isEntrypoint) {
+        if (!artifact.entrypointIndex[filePath])
+          artifact.entrypointIndex[filePath] = [];
+        artifact.entrypointIndex[filePath].push(fn.functionId);
+      }
+    }
+  }
+  for (const fileRec of Object.values(artifact.files)) {
+    for (const fnRec of fileRec.functions) {
+      for (const callRec of fnRec.calls) {
+        if (callRec.resolutionKind === "named_import_match" && callRec.resolvedFilePath) {
+          const targetFile = artifact.files[callRec.resolvedFilePath];
+          if (targetFile) {
+            const targetFn = targetFile.functions.find((f) => f.displayName === callRec.calleeRoot);
+            if (targetFn) {
+              callRec.resolvedTargetFunctionId = targetFn.functionId;
+            }
+          }
+        }
+      }
+    }
+  }
+  await writeFile7(join7(projectRoot, ".vibe-splainer", "action_bindings.json"), JSON.stringify(artifact, null, 2), "utf8");
+  const summary = {
+    filesProcessed,
+    functionsExtracted,
+    callsExtracted,
+    callsResolved,
+    semanticActionsExtracted,
+    entrypointsFound,
+    namedImportsExtracted
+  };
+  await writeFile7(join7(projectRoot, ".vibe-splainer", "stage-09-action-bindings-summary.json"), JSON.stringify(summary, null, 2), "utf8");
+  return { artifact };
+}
+async function traverseCallChain(projectRoot, args) {
+  const artifactPath = join7(projectRoot, ".vibe-splainer", "action_bindings.json");
+  let artifact;
+  try {
+    const raw = await readFile6(artifactPath, "utf8");
+    artifact = JSON.parse(raw);
+  } catch {
+    throw new Error("action_bindings.json not found. Run scan_project first.");
+  }
+  const { entrypointPath, maxDepth = 6, targetActionKind, targetModel, targetOperation, targetFunctionName, includeTests = false } = args;
+  let seedFunctionIds = [];
+  if (artifact.entrypointIndex[entrypointPath]) {
+    seedFunctionIds = artifact.entrypointIndex[entrypointPath];
+  } else if (artifact.files[entrypointPath]) {
+    const fileRec = artifact.files[entrypointPath];
+    seedFunctionIds = fileRec.functions.filter((f) => f.isEntrypoint).map((f) => f.functionId);
+    if (seedFunctionIds.length === 0) {
+      const firstExported = fileRec.functions.find((f) => f.isExported);
+      if (firstExported)
+        seedFunctionIds.push(firstExported.functionId);
+    }
+  }
+  if (seedFunctionIds.length === 0) {
+    throw new Error(`No entrypoint functions found in ${entrypointPath}`);
+  }
+  const chain = [];
+  const unresolvedEdges = [];
+  const visited = /* @__PURE__ */ new Set();
+  const queue = seedFunctionIds.map((id) => ({ functionId: id, depth: 0 }));
+  let targetReached = false;
+  let truncatedAtDepth = false;
+  while (queue.length > 0) {
+    const { functionId, depth } = queue.shift();
+    if (visited.has(functionId))
+      continue;
+    visited.add(functionId);
+    const indexEntry = artifact.functionIndex[functionId];
+    if (!indexEntry)
+      continue;
+    const fileRec = artifact.files[indexEntry.filePath];
+    if (!fileRec)
+      continue;
+    if (!includeTests && fileRec.sourceRole === "test")
+      continue;
+    const fnRec = fileRec.functions.find((f) => f.functionId === functionId);
+    if (!fnRec)
+      continue;
+    for (const call of fnRec.calls) {
+      if (call.resolutionKind === "semantic_action_only")
+        continue;
+      if (call.resolvedTargetFunctionId) {
+        if (depth < maxDepth) {
+          queue.push({ functionId: call.resolvedTargetFunctionId, depth: depth + 1 });
+          let isTarget = false;
+          if (targetFunctionName && call.calleeRoot === targetFunctionName)
+            isTarget = true;
+          if (isTarget)
+            targetReached = true;
+          chain.push({
+            functionId: call.resolvedTargetFunctionId,
+            displayName: call.calleeRoot,
+            filePath: call.resolvedFilePath || "unknown",
+            startLine: call.sourceLine,
+            edgeKind: "call_edge",
+            confidence: call.confidence,
+            evidenceText: call.evidenceText,
+            isTarget,
+            depth
+          });
+        } else {
+          unresolvedEdges.push({
+            fromFunctionId: functionId,
+            calleeText: call.calleeText,
+            sourceLine: call.sourceLine,
+            reason: "depth limit reached"
+          });
+          truncatedAtDepth = true;
+        }
+      } else {
+        unresolvedEdges.push({
+          fromFunctionId: functionId,
+          calleeText: call.calleeText,
+          sourceLine: call.sourceLine,
+          reason: call.resolutionKind
+        });
+      }
+    }
+    for (const action of fnRec.semanticActions) {
+      let isTarget = false;
+      if (targetActionKind && action.actionKind === targetActionKind) {
+        isTarget = true;
+        if (targetModel && action.targetModel !== targetModel)
+          isTarget = false;
+        if (targetOperation && action.targetOperation !== targetOperation)
+          isTarget = false;
+      } else if (targetModel && action.targetModel === targetModel) {
+        isTarget = true;
+        if (targetOperation && action.targetOperation !== targetOperation)
+          isTarget = false;
+      }
+      if (isTarget)
+        targetReached = true;
+      chain.push({
+        functionId: action.sourceFunctionId,
+        displayName: action.calleeText,
+        filePath: fileRec.filePath,
+        startLine: action.sourceLine,
+        edgeKind: "semantic_action",
+        actionKind: action.actionKind,
+        targetModel: action.targetModel || void 0,
+        targetOperation: action.targetOperation || void 0,
+        confidence: action.confidence,
+        evidenceText: action.evidenceText,
+        isTarget,
+        depth
+      });
+    }
+  }
+  return {
+    targetReached,
+    truncatedAtDepth,
+    chain,
+    unresolvedEdges
+  };
+}
+
+// ../brain/dist/pipeline/scoring.js
+import { join as join8 } from "path";
+import { writeFile as writeFile8, mkdir as mkdir6, readFile as readFile7 } from "fs/promises";
 import { createHash } from "crypto";
 function computeSeverity(sideEffectProfile, productDomain, gravity, heat, maxNesting, hasLongFunctions, swallowedCatches, runtimeEntrypoints) {
   let score = 0;
@@ -2113,6 +2741,11 @@ function applyCorrections(file) {
   }
   if (file.canonicalSeverity === 5)
     file.canonicalLoadBearing = true;
+  if (file.riskTypes.includes("registry_bottleneck")) {
+    if (file.canonicalSeverity < 4)
+      file.canonicalSeverity = 4;
+    file.canonicalLoadBearing = true;
+  }
 }
 function inferObservableOutputs(frameworkRole, productDomain, sideEffectProfile) {
   const outputs = [];
@@ -2141,6 +2774,9 @@ function inferObservableOutputs(frameworkRole, productDomain, sideEffectProfile)
     outputs.push("sdk_event_name");
   if (frameworkRole === "hook" || frameworkRole === "store")
     outputs.push("ui_state_transition");
+  if (productDomain === "data_table" && frameworkRole === "provider") {
+    outputs.push("ui_state_transition", "filter_state", "selected_segment");
+  }
   return [...new Set(outputs)];
 }
 function inferPatchRisk(productDomain, riskTypes, sideEffectProfile, importedByCount, loadBearingScore) {
@@ -2157,9 +2793,21 @@ function inferPatchRisk(productDomain, riskTypes, sideEffectProfile, importedByC
       reason: `${productDomain} writes to external state (${external.join(", ") || "database"}). Changes require integration testing.`
     };
   }
+  if (riskTypes.includes("registry_bottleneck")) {
+    return {
+      level: "high",
+      reason: "registry_bottleneck: central dispatch point \u2014 blast radius not measurable by fan-in alone."
+    };
+  }
   if (loadBearingScore >= 5 || importedByCount >= 5) {
     return { level: "medium", reason: `Imported by ${importedByCount} files. Interface changes will cascade.` };
   }
+  if (productDomain === "data_table" && riskTypes.includes("state_machine")) {
+    return {
+      level: "medium",
+      reason: "data_table state machine: controls user-visible workflow state (filters, segments, pagination) \u2014 regression risk not captured by mutation scoring."
+    };
+  }
   return { level: "low", reason: "Locally contained \u2014 limited blast radius." };
 }
 function inferSafePatchStrategy(riskTypes, sideEffectProfile) {
@@ -2249,9 +2897,17 @@ function deriveConfidence(fanIn, gravity) {
     return "medium";
   return "low";
 }
-async function runScoring(projectRoot, cr) {
-  const dir = join7(projectRoot, ".vibe-splainer");
+async function runScoring(projectRoot, cr, binding) {
+  const dir = join8(projectRoot, ".vibe-splainer");
   await mkdir6(dir, { recursive: true });
+  let bindingArtifact = binding?.artifact;
+  if (!bindingArtifact) {
+    try {
+      const raw = await readFile7(join8(projectRoot, ".vibe-splainer", "action_bindings.json"), "utf8");
+      bindingArtifact = JSON.parse(raw);
+    } catch {
+    }
+  }
   const persisted = {};
   const severityBreakdowns = {};
   for (const f of cr.classified) {
@@ -2285,7 +2941,7 @@ async function runScoring(projectRoot, cr) {
     severityBreakdowns[f.rel] = `severity=${pf.canonicalSeverity} loadBearing=${pf.canonicalLoadBearing} effects=${pf.sideEffectProfile.join(",")} domain=${pf.productDomain}`;
   }
   const stage09 = Object.fromEntries(Object.entries(persisted).filter(([, pf]) => pf.isRealSource).map(([rel, pf]) => [rel, { canonicalSeverity: pf.canonicalSeverity, canonicalLoadBearing: pf.canonicalLoadBearing, scoreBreakdown: severityBreakdowns[rel] }]));
-  await writeFile7(join7(dir, "stage-09-severity.json"), JSON.stringify(stage09, null, 2), "utf8");
+  await writeFile8(join8(dir, "stage-09-severity.json"), JSON.stringify(stage09, null, 2), "utf8");
   const store = { files: persisted };
   const importedByMapForDelta = /* @__PURE__ */ new Map();
   for (const [rel, pf] of Object.entries(persisted)) {
@@ -2306,9 +2962,89 @@ async function runScoring(projectRoot, cr) {
       file: pf.relativePath,
       startLine: span.startLine,
       endLine: span.endLine,
-      rawSourceExcerpt: span.snippet,
-      evidenceHash: createHash("sha256").update(span.snippet).digest("hex").slice(0, 12)
+      rawSourceExcerpt: span.rawExcerpt,
+      evidenceHash: createHash("sha256").update(span.rawExcerpt).digest("hex").slice(0, 12)
     }));
+    const displayEvidence = pf.hotSpans.map((span) => ({
+      file: pf.relativePath,
+      startLine: span.startLine,
+      endLine: span.endLine,
+      excerpt: span.snippet,
+      isTruncated: span.rawExcerpt.length > 2e3
+    }));
+    let criticalFunctions = void 0;
+    if (bindingArtifact) {
+      const fileBinding = bindingArtifact.files[pf.relativePath];
+      if (fileBinding) {
+        const scoredFunctions = fileBinding.functions.map((fn) => {
+          let fnScore = 0;
+          const reasons = [];
+          if (fn.semanticActions.length > 0) {
+            fnScore += 3;
+            reasons.push("Contains semantic actions");
+          }
+          if (fn.isEntrypoint) {
+            fnScore += 2;
+            reasons.push("Is a framework entrypoint");
+          }
+          const resolvedOutbound = fn.calls.filter((c) => c.resolvedTargetFunctionId).length;
+          if (resolvedOutbound > 0) {
+            const callPts = Math.min(3, resolvedOutbound);
+            fnScore += callPts;
+            reasons.push(`Has ${resolvedOutbound} resolved outbound calls`);
+          }
+          const writesModel = fn.semanticActions.some((a) => a.actionKind === "database_write" && a.targetModel);
+          if (writesModel) {
+            fnScore += 2;
+            reasons.push("Writes to a database model");
+          }
+          const authOrValid = fn.semanticActions.some((a) => a.actionKind === "auth_check" || a.actionKind === "validation");
+          if (authOrValid) {
+            fnScore += 1;
+            reasons.push("Performs auth/validation");
+          }
+          return { fn, fnScore, reasons };
+        });
+        scoredFunctions.sort((a, b) => b.fnScore - a.fnScore);
+        const topFns = scoredFunctions.slice(0, 5);
+        if (topFns.length > 0) {
+          criticalFunctions = topFns.map(({ fn, reasons }) => {
+            const evidence = fn.semanticActions.slice(0, 5).sort((a, b) => a.sourceLine - b.sourceLine).map((a) => ({
+              sourceLine: a.sourceLine,
+              text: a.evidenceText,
+              actionKind: a.actionKind,
+              targetModel: a.targetModel,
+              targetOperation: a.targetOperation,
+              confidence: a.confidence
+            }));
+            const confidences = fn.semanticActions.map((a) => a.confidence);
+            let confidence2 = "high";
+            if (confidences.includes("low"))
+              confidence2 = "low";
+            else if (confidences.includes("medium"))
+              confidence2 = "medium";
+            return {
+              functionId: fn.functionId,
+              displayName: fn.displayName,
+              functionKind: fn.functionKind,
+              startLine: fn.startLine,
+              endLine: fn.endLine,
+              isEntrypoint: fn.isEntrypoint,
+              isExported: fn.isExported,
+              actionKinds: [...new Set(fn.semanticActions.map((a) => a.actionKind))],
+              targetModels: [...new Set(fn.semanticActions.map((a) => a.targetModel).filter(Boolean))],
+              targetOperations: [...new Set(fn.semanticActions.map((a) => a.targetOperation).filter(Boolean))],
+              outboundCallCount: fn.calls.length,
+              resolvedOutboundCallCount: fn.calls.filter((c) => c.resolvedTargetFunctionId).length,
+              semanticActionCount: fn.semanticActions.length,
+              evidence,
+              confidence: confidence2,
+              reasons
+            };
+          });
+        }
+      }
+    }
     return {
       path: pf.relativePath,
       frameworkRole: pf.frameworkRole,
@@ -2332,17 +3068,19 @@ async function runScoring(projectRoot, cr) {
       doNotTouch: inferDoNotTouch(pf.sideEffectProfile, pf.productDomain),
       testProbes: inferTestProbes(pf.writeIntents, observableOutputs),
       rawEvidence,
+      displayEvidence,
+      criticalFunctions,
       analysisAnnotation: `${pf.frameworkRole} in ${pf.productDomain} domain. fanIn=${pf.gravitySignals.fanIn} cyclomatic=${pf.gravitySignals.cyclomatic} loc=${pf.gravitySignals.loc}`,
       hashes: { fileHash, evidenceHash: rawEvidence.map((e) => e.evidenceHash).join("-") }
     };
   });
-  const dest = join7(dir, "delta_targets.json");
+  const dest = join8(dir, "delta_targets.json");
   const tmp = dest + ".tmp";
-  await writeFile7(tmp, JSON.stringify(deltaTargets, null, 2), "utf8");
+  await writeFile8(tmp, JSON.stringify(deltaTargets, null, 2), "utf8");
   const { rename } = await import("fs/promises");
   await rename(tmp, dest);
-  const validationReport = buildValidationReport(store, deltaTargets);
-  await writeFile7(join7(dir, "validation_report.json"), JSON.stringify(validationReport, null, 2), "utf8");
+  const validationReport = await buildValidationReport(store, deltaTargets, projectRoot);
+  await writeFile8(join8(dir, "validation_report.json"), JSON.stringify(validationReport, null, 2), "utf8");
   for (const e of validationReport.errors) {
     console.error(`[vibe-splain] VALIDATION ERROR [${e.rule}] ${e.file}: ${e.detail}`);
   }
@@ -2351,7 +3089,7 @@ async function runScoring(projectRoot, cr) {
   }
   return { store, deltaTargets, validationReport };
 }
-function buildValidationReport(store, deltaTargets) {
+async function buildValidationReport(store, deltaTargets, projectRoot) {
   const errors = [];
   const warnings = [];
   let passCount = 0;
@@ -2421,8 +3159,109 @@ function buildValidationReport(store, deltaTargets) {
         detail: `Entrypoints found but domain surface mismatch for ${pf.productDomain}. Found: ${foundPaths}`
       });
     }
+    if (pf.riskTypes.includes("registry_bottleneck")) {
+      if (pf.canonicalSeverity < 4)
+        errors.push({
+          file: pf.relativePath,
+          rule: "registry_bottleneck_severity",
+          detail: "registry_bottleneck file must have severity >= 4",
+          expected: ">=4",
+          actual: String(pf.canonicalSeverity)
+        });
+      if (!pf.canonicalLoadBearing)
+        errors.push({
+          file: pf.relativePath,
+          rule: "registry_bottleneck_load_bearing",
+          detail: "registry_bottleneck file must be load-bearing",
+          expected: "true",
+          actual: "false"
+        });
+      if (delta && delta.patchRisk.level !== "high" && delta.patchRisk.level !== "critical")
+        errors.push({
+          file: pf.relativePath,
+          rule: "registry_bottleneck_patch_risk",
+          detail: "registry_bottleneck file must have patch risk high or critical",
+          expected: "high|critical",
+          actual: delta?.patchRisk.level ?? "unknown"
+        });
+    }
+    if (pf.productDomain === "data_table" && pf.riskTypes.includes("state_machine") && delta?.patchRisk.level === "low") {
+      warnings.push({
+        file: pf.relativePath,
+        rule: "data_table_state_machine_risk",
+        detail: "data_table state machine should have at least medium patch risk"
+      });
+    }
     passCount++;
   }
+  const PAYMENT_PROVIDER_PATH_TERMS = ["stripe", "paypal", "btcpay", "btcpayserver", "alby", "hitpay", "payment"];
+  const PAYMENT_CONTENT_TERMS = [
+    "constructEvent",
+    "checkoutSession",
+    "paymentIntent",
+    "stripe-signature",
+    "webhook-signature",
+    "payment_mutation",
+    "paymentStatus",
+    "invoicePaid",
+    "chargeSucceeded"
+  ];
+  for (const [rel, pf] of Object.entries(store.files)) {
+    if (!pf.isRealSource)
+      continue;
+    const pathLower = rel.toLowerCase();
+    if (!pathLower.includes("webhook"))
+      continue;
+    const primaryTrigger = PAYMENT_PROVIDER_PATH_TERMS.some((t) => pathLower.includes(t));
+    let secondaryTrigger = false;
+    if (!primaryTrigger && pf.productDomain !== "payments_webhooks") {
+      try {
+        const src = await readFile7(join8(projectRoot, rel), "utf8");
+        secondaryTrigger = PAYMENT_CONTENT_TERMS.some((t) => src.includes(t));
+      } catch {
+      }
+    }
+    if (!primaryTrigger && !secondaryTrigger)
+      continue;
+    const delta = deltaByPath.get(rel);
+    const triggerLabel = primaryTrigger ? "path" : "content";
+    const webhookChecks = [
+      [
+        pf.productDomain !== "payments_webhooks",
+        "webhook_domain",
+        `Payment webhook (${triggerLabel} trigger) not classified as payments_webhooks`
+      ],
+      [
+        !pf.sideEffectProfile.includes("webhook_ingress"),
+        "webhook_ingress_missing",
+        `Payment webhook (${triggerLabel} trigger) missing webhook_ingress side effect`
+      ],
+      [
+        !pf.sideEffectProfile.includes("payment_mutation"),
+        "webhook_payment_mutation_missing",
+        `Payment webhook (${triggerLabel} trigger) missing payment_mutation side effect`
+      ],
+      [
+        !pf.writeIntents.includes("handle_payment_webhook"),
+        "webhook_write_intent_missing",
+        `Payment webhook (${triggerLabel} trigger) missing handle_payment_webhook write intent`
+      ],
+      [
+        !!delta && delta.patchRisk.level !== "high" && delta.patchRisk.level !== "critical",
+        "webhook_patch_risk",
+        `Payment webhook (${triggerLabel} trigger) patchRisk must be high or critical`
+      ],
+      [
+        !pf.canonicalLoadBearing,
+        "webhook_load_bearing",
+        `Payment webhook (${triggerLabel} trigger) must be load-bearing`
+      ]
+    ];
+    for (const [condition, rule, detail] of webhookChecks) {
+      if (condition)
+        errors.push({ file: rel, rule, detail });
+    }
+  }
   return {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     passed: errors.length === 0,
@@ -2436,8 +3275,9 @@ function buildValidationReport(store, deltaTargets) {
 async function runPipeline(projectRoot) {
   const inv = await runInventory(projectRoot);
   const res = await runResolution(projectRoot, inv);
+  const binding = await runActionBinding(projectRoot, inv, res);
   const cr = await runClassification(projectRoot, inv, res);
-  const scoring = await runScoring(projectRoot, cr);
+  const scoring = await runScoring(projectRoot, cr, binding);
   await writeGraph(projectRoot, res.graph);
   await writeAnalysis(projectRoot, scoring.store);
   const files = cr.classified.filter((f) => f.isRealSource).sort((a, b) => b.gravity - a.gravity).map((f) => ({
@@ -2472,7 +3312,7 @@ async function runPipeline(projectRoot) {
     productDomain: f.productDomain,
     sideEffectProfile: f.sideEffectProfile
   }));
-  const uiUrl = `file://${join8(projectRoot, ".vibe-splainer", "ui", "index.html")}`;
+  const uiUrl = `file://${join9(projectRoot, ".vibe-splainer", "ui", "index.html")}`;
   return {
     projectRoot,
     totalFilesScanned: cr.classified.length,
@@ -2505,7 +3345,7 @@ async function getFileAnalysis(absPath) {
     return null;
   let source;
   try {
-    source = await readFile6(absPath, "utf8");
+    source = await readFile8(absPath, "utf8");
   } catch {
     return null;
   }
@@ -2544,16 +3384,16 @@ async function getFileAnalysis(absPath) {
 
 // ../brain/dist/dossier.js
 import { Mutex } from "async-mutex";
-import { join as join9, dirname as dirname3 } from "path";
+import { join as join10, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { readFile as readFile7, writeFile as writeFile8, mkdir as mkdir7 } from "fs/promises";
+import { readFile as readFile9, writeFile as writeFile9, mkdir as mkdir7 } from "fs/promises";
 import { existsSync as existsSync4, cpSync } from "fs";
 var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
 var dossierMutex = new Mutex();
 async function readDossier(projectRoot) {
-  const dossierPath = join9(projectRoot, ".vibe-splainer", "dossier.json");
+  const dossierPath = join10(projectRoot, ".vibe-splainer", "dossier.json");
   try {
-    const raw = await readFile7(dossierPath, "utf8");
+    const raw = await readFile9(dossierPath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -2565,33 +3405,33 @@ async function writeDossier(projectRoot, dossier) {
       p.decisions = p.decisions.filter((c) => !(c.severity === 1 && c.category === "Convention"));
       p.cardCount = p.decisions.length;
     }
-    const dir = join9(projectRoot, ".vibe-splainer");
+    const dir = join10(projectRoot, ".vibe-splainer");
     await mkdir7(dir, { recursive: true });
-    const dossierPath = join9(dir, "dossier.json");
+    const dossierPath = join10(dir, "dossier.json");
     const tmp = dossierPath + ".tmp";
-    await writeFile8(tmp, JSON.stringify(dossier, null, 2), "utf8");
+    await writeFile9(tmp, JSON.stringify(dossier, null, 2), "utf8");
     const { rename } = await import("fs/promises");
     await rename(tmp, dossierPath);
     await regenerateUI(projectRoot, dossier);
   });
 }
 async function regenerateUI(projectRoot, dossier) {
-  const uiDir = join9(projectRoot, ".vibe-splainer", "ui");
+  const uiDir = join10(projectRoot, ".vibe-splainer", "ui");
   await mkdir7(uiDir, { recursive: true });
-  let templateDir = join9(__dirname2, "ui");
+  let templateDir = join10(__dirname2, "ui");
   if (!existsSync4(templateDir)) {
-    templateDir = join9(__dirname2, "../../cli/dist/ui");
+    templateDir = join10(__dirname2, "../../cli/dist/ui");
   }
   if (!existsSync4(templateDir)) {
     console.error("[vibe-splain] UI template not found at", templateDir, "- skipping UI regeneration");
     return;
   }
   cpSync(templateDir, uiDir, { recursive: true });
-  let html = await readFile7(join9(templateDir, "index.html"), "utf8");
+  let html = await readFile9(join10(templateDir, "index.html"), "utf8");
   const injection = `<script>window.__VIBE_DOSSIER__ = ${JSON.stringify(dossier)};</script>`;
   html = html.replace("<!-- VIBE_DOSSIER_INJECTION_POINT -->", injection);
-  await writeFile8(join9(uiDir, "index.html"), html, "utf8");
-  console.error("[vibe-splain] UI regenerated at", join9(uiDir, "index.html"));
+  await writeFile9(join10(uiDir, "index.html"), html, "utf8");
+  console.error("[vibe-splain] UI regenerated at", join10(uiDir, "index.html"));
 }
 function validateMermaidNodeCount(diagram) {
   if (!diagram)
@@ -2611,8 +3451,8 @@ function validateMermaidNodeCount(diagram) {
 // ../brain/dist/watcher.js
 import chokidar from "chokidar";
 import { createHash as createHash2 } from "crypto";
-import { readFile as readFile8 } from "fs/promises";
-import { join as join10 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { join as join11 } from "path";
 function startWatcher(projectRoot, watchedPaths) {
   const watcher = chokidar.watch(watchedPaths.length > 0 ? watchedPaths : projectRoot, {
     ignoreInitial: true,
@@ -2624,14 +3464,14 @@ function startWatcher(projectRoot, watchedPaths) {
       const dossier = await readDossier(projectRoot);
       if (!dossier)
         return;
-      const content = await readFile8(filepath, "utf8");
+      const content = await readFile10(filepath, "utf8");
       const newHash = createHash2("sha256").update(content).digest("hex");
       let mutated = false;
       for (const pillar of dossier.pillars) {
         for (const card of pillar.decisions) {
           if (!card.primaryFile)
             continue;
-          const absMatch = filepath === join10(projectRoot, card.primaryFile) || filepath.endsWith("/" + card.primaryFile);
+          const absMatch = filepath === join11(projectRoot, card.primaryFile) || filepath.endsWith("/" + card.primaryFile);
           if (absMatch && card.lastScannedHash !== newHash) {
             card.status = "stale";
             const rel = card.primaryFile;
@@ -2801,8 +3641,8 @@ async function handleSetProjectBrief(args) {
 }
 
 // dist/mcp/tools/get_file_context.js
-import { readFile as readFile9 } from "fs/promises";
-import { join as join11, relative as relative3, isAbsolute } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join12, relative as relative3, isAbsolute } from "path";
 var getFileContextTool = {
   name: "get_file_context",
   description: "Returns PRE-EXTRACTED evidence for a file so you do not have to read the whole thing and paraphrase its header comment. Returns: gravity/heat scores + signals, importedBy (named fan-in \u2014 use this for blastRadius), hotSpans (the gnarliest function bodies, comment-stripped, each with a reason), smellSpans (located tech debt with \xB13 lines of context), and signature (the exported API surface). Base your evidence on hotSpans/smellSpans \u2014 NEVER on header comments. Pass { full: true } only if you truly need the raw source.",
@@ -2822,7 +3662,7 @@ async function handleGetFileContext(args) {
   const full = args.full === true;
   if (!projectRoot || !filePath)
     throw new Error("projectRoot and filePath are required");
-  const fullPath = isAbsolute(filePath) ? filePath : join11(projectRoot, filePath);
+  const fullPath = isAbsolute(filePath) ? filePath : join12(projectRoot, filePath);
   const relPath = relative3(projectRoot, fullPath);
   const evidence = await getFileAnalysis(fullPath);
   if (!evidence) {
@@ -2847,7 +3687,7 @@ async function handleGetFileContext(args) {
     smellSpans: evidence.smellSpans
   };
   if (full) {
-    result.source = await readFile9(fullPath, "utf8");
+    result.source = await readFile11(fullPath, "utf8");
   }
   return result;
 }
@@ -2855,8 +3695,8 @@ async function handleGetFileContext(args) {
 // dist/mcp/tools/write_decision_card.js
 import { v4 as uuidv4 } from "uuid";
 import { createHash as createHash3 } from "crypto";
-import { readFile as readFile10 } from "fs/promises";
-import { join as join12 } from "path";
+import { readFile as readFile12 } from "fs/promises";
+import { join as join13 } from "path";
 var CATEGORIES = ["Bottleneck", "Hack", "Smart-Move", "Risk", "Convention", "Dead-Weight"];
 function normalizeSnippet(s) {
   let out = (s ?? "").replace(/\r\n/g, "\n");
@@ -2948,7 +3788,7 @@ async function handleWriteDecisionCard(args) {
   const heat = persisted ? Math.round(persisted.heat) : void 0;
   let primaryContent = "";
   try {
-    primaryContent = await readFile10(join12(projectRoot, primaryFile), "utf8");
+    primaryContent = await readFile12(join13(projectRoot, primaryFile), "utf8");
   } catch {
   }
   const hash = createHash3("sha256").update(primaryContent).digest("hex");
@@ -3168,12 +4008,62 @@ async function handleMarkStale(args) {
   };
 }
 
+// dist/mcp/tools/get_call_chain.js
+var getCallChainTool = {
+  name: "get_call_chain",
+  description: `Trace how behavior is reached from an entrypoint by following function call edges through the codebase. Returns a step-by-step chain with exact function names, file paths, line numbers, action kinds, and evidence text. Every edge has a confidence level; unresolved edges are listed explicitly.
+
+Use structured filters when you know the target:
+  targetModel + targetOperation: "where does Booking get created?"
+  targetActionKind: "where is auth enforced?"  
+  targetFunctionName: "how is function X reached?"
+No filter returns the full call tree up to maxDepth.
+
+Run scan_project first \u2014 this tool reads from the generated action_bindings.json.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      projectRoot: { type: "string" },
+      entrypointPath: { type: "string", description: "Relative path to the entrypoint file" },
+      maxDepth: { type: "number", description: "Max traversal depth. Default 6, max 12." },
+      targetActionKind: { type: "string", description: "Stop at this semantic action kind." },
+      targetModel: { type: "string", description: "Stop at functions touching this model." },
+      targetOperation: { type: "string", description: "Narrow targetModel to this operation." },
+      targetFunctionName: { type: "string", description: "Stop at a specific function name." },
+      includeTests: { type: "boolean", description: "Include test files in traversal. Default false." }
+    },
+    required: ["projectRoot", "entrypointPath"]
+  }
+};
+async function handleGetCallChain(args) {
+  const projectRoot = args.projectRoot;
+  const entrypointPath = args.entrypointPath;
+  if (!projectRoot || !entrypointPath)
+    throw new Error("projectRoot and entrypointPath are required");
+  const getCallChainArgs = {
+    entrypointPath,
+    maxDepth: typeof args.maxDepth === "number" ? args.maxDepth : void 0,
+    targetActionKind: typeof args.targetActionKind === "string" ? args.targetActionKind : void 0,
+    targetModel: typeof args.targetModel === "string" ? args.targetModel : void 0,
+    targetOperation: typeof args.targetOperation === "string" ? args.targetOperation : void 0,
+    targetFunctionName: typeof args.targetFunctionName === "string" ? args.targetFunctionName : void 0,
+    includeTests: typeof args.includeTests === "boolean" ? args.includeTests : void 0
+  };
+  try {
+    const result = await traverseCallChain(projectRoot, getCallChainArgs);
+    return result;
+  } catch (error) {
+    throw new Error(`get_call_chain failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
 // dist/mcp/server.js
 var ALL_TOOLS = [
   scanProjectTool,
   getProjectMapTool,
   setProjectBriefTool,
   getFileContextTool,
+  getCallChainTool,
   writeDecisionCardTool,
   getStrategicOverviewTool,
   inspectPillarTool,
@@ -3185,6 +4075,7 @@ var TOOL_HANDLERS = {
   get_project_map: handleGetProjectMap,
   set_project_brief: handleSetProjectBrief,
   get_file_context: handleGetFileContext,
+  get_call_chain: handleGetCallChain,
   write_decision_card: handleWriteDecisionCard,
   get_strategic_overview: handleGetStrategicOverview,
   inspect_pillar: handleInspectPillar,