vibe-splain 2.7.2 → 3.0.0

package/dist/index.js

@@ -89,49 +89,17 @@ import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema
 
 // ../brain/dist/scanner.js
 import { extname as extname4 } from "path";
-import { readFile as readFile8 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 
 // ../brain/dist/pipeline/orchestrator.js
-import { join as join9 } from "path";
-
-// ../brain/dist/graph.js
-import { join as join2 } from "path";
-import { readFile as readFile2, writeFile as writeFile2, mkdir } from "fs/promises";
-async function writeGraph(projectRoot, graph) {
-  const dir = join2(projectRoot, ".vibe-splainer");
-  await mkdir(dir, { recursive: true });
-  const graphPath = join2(dir, "graph.json");
-  await writeFile2(graphPath, JSON.stringify(graph, null, 2), "utf8");
-}
-
-// ../brain/dist/analysis.js
-import { join as join3 } from "path";
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
-async function readAnalysis(projectRoot) {
-  const p = join3(projectRoot, ".vibe-splainer", "analysis.json");
-  try {
-    const raw = await readFile3(p, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-async function writeAnalysis(projectRoot, store) {
-  const dir = join3(projectRoot, ".vibe-splainer");
-  await mkdir2(dir, { recursive: true });
-  const dest = join3(dir, "analysis.json");
-  const tmp = dest + ".tmp";
-  await writeFile3(tmp, JSON.stringify(store, null, 2), "utf8");
-  const { rename } = await import("fs/promises");
-  await rename(tmp, dest);
-}
+import { join as join7 } from "path";
 
 // ../brain/dist/pipeline/inventory.js
 import Parser from "web-tree-sitter";
-import { join as join4, dirname, relative, extname, basename, sep } from "path";
+import { join as join2, dirname, relative, extname, basename, sep } from "path";
 import { fileURLToPath } from "url";
 import { createRequire } from "module";
-import { readFile as readFile4, readdir, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
+import { readFile as readFile2, readdir, writeFile as writeFile2, mkdir } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var require2 = createRequire(import.meta.url);
@@ -162,12 +130,12 @@ var SUPPORTED_EXTENSIONS = new Set(Object.keys(EXT_LANG));
 function resolveWasm(file) {
   try {
     const wasmsDir = dirname(require2.resolve("tree-sitter-wasms/package.json"));
-    const p = join4(wasmsDir, "out", file);
+    const p = join2(wasmsDir, "out", file);
     if (existsSync2(p))
       return p;
   } catch {
   }
-  const local = join4(__dirname, "../../wasm", file);
+  const local = join2(__dirname, "../../wasm", file);
   return existsSync2(local) ? local : null;
 }
 async function getLanguage(lang) {
@@ -275,7 +243,7 @@ async function collectFiles(dir, projectRoot, acc) {
     }
     if (EXCLUDE_DIRS.has(entry.name))
       continue;
-    const fullPath = join4(dir, entry.name);
+    const fullPath = join2(dir, entry.name);
     if (entry.isDirectory()) {
       await collectFiles(fullPath, projectRoot, acc);
     } else if (entry.isFile()) {
@@ -692,10 +660,10 @@ async function detectStackAndEntrypoints(projectRoot, files) {
   const stack = /* @__PURE__ */ new Set();
   const entrypoints = /* @__PURE__ */ new Set();
   const rel = (abs) => relative(projectRoot, abs);
-  const pkgPath = join4(projectRoot, "package.json");
+  const pkgPath = join2(projectRoot, "package.json");
   if (existsSync2(pkgPath)) {
     try {
-      const pkg = JSON.parse(await readFile4(pkgPath, "utf8"));
+      const pkg = JSON.parse(await readFile2(pkgPath, "utf8"));
       stack.add("Node.js");
       const deps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
       for (const known of ["react", "next", "vue", "svelte", "express", "fastify", "typescript", "vite"]) {
@@ -705,7 +673,7 @@ async function detectStackAndEntrypoints(projectRoot, files) {
       const addEntry = (p) => {
         if (!p)
           return;
-        const abs = join4(projectRoot, p);
+        const abs = join2(projectRoot, p);
         const r = relative(projectRoot, abs);
         if (files.includes(abs))
           entrypoints.add(r);
@@ -719,16 +687,16 @@ async function detectStackAndEntrypoints(projectRoot, files) {
     } catch {
     }
   }
-  const pyproject = join4(projectRoot, "pyproject.toml");
-  const setupPy = join4(projectRoot, "setup.py");
-  const requirements = join4(projectRoot, "requirements.txt");
+  const pyproject = join2(projectRoot, "pyproject.toml");
+  const setupPy = join2(projectRoot, "setup.py");
+  const requirements = join2(projectRoot, "requirements.txt");
   if (existsSync2(pyproject) || existsSync2(setupPy) || existsSync2(requirements)) {
     stack.add("Python");
     let reqText = "";
     for (const f of [pyproject, requirements]) {
       if (existsSync2(f)) {
         try {
-          reqText += await readFile4(f, "utf8");
+          reqText += await readFile2(f, "utf8");
         } catch {
         }
       }
@@ -738,11 +706,11 @@ async function detectStackAndEntrypoints(projectRoot, files) {
         stack.add(known);
     }
   }
-  if (existsSync2(join4(projectRoot, "go.mod")))
+  if (existsSync2(join2(projectRoot, "go.mod")))
     stack.add("Go");
-  if (existsSync2(join4(projectRoot, "Cargo.toml")))
+  if (existsSync2(join2(projectRoot, "Cargo.toml")))
     stack.add("Rust");
-  if (existsSync2(join4(projectRoot, "pom.xml")) || existsSync2(join4(projectRoot, "build.gradle")))
+  if (existsSync2(join2(projectRoot, "pom.xml")) || existsSync2(join2(projectRoot, "build.gradle")))
     stack.add("Java");
   for (const abs of files) {
     const r = rel(abs);
@@ -1168,7 +1136,7 @@ async function runInventory(projectRoot) {
       continue;
     let source;
     try {
-      source = await readFile4(file, "utf8");
+      source = await readFile2(file, "utf8");
     } catch {
       continue;
     }
@@ -1197,8 +1165,8 @@ async function runInventory(projectRoot) {
       productDomain
     });
   }
-  const dir = join4(projectRoot, ".vibe-splainer");
-  await mkdir3(dir, { recursive: true });
+  const dir = join2(projectRoot, ".vibe-splainer");
+  await mkdir(dir, { recursive: true });
   const stage01 = {
     files: work.map((w) => ({
       absPath: w.abs,
@@ -1209,17 +1177,17 @@ async function runInventory(projectRoot) {
     totalCount: work.length,
     realSourceCount: work.filter((w) => !w.pathDemote).length
   };
-  await writeFile4(join4(dir, "stage-01-inventory.json"), JSON.stringify(stage01, null, 2), "utf8");
+  await writeFile2(join2(dir, "stage-01-inventory.json"), JSON.stringify(stage01, null, 2), "utf8");
   const stage02 = Object.fromEntries(work.map((w) => [w.rel, w.frameworkRole]));
-  await writeFile4(join4(dir, "stage-02-framework-roles.json"), JSON.stringify(stage02, null, 2), "utf8");
+  await writeFile2(join2(dir, "stage-02-framework-roles.json"), JSON.stringify(stage02, null, 2), "utf8");
   const stage03 = Object.fromEntries(work.map((w) => [w.rel, w.productDomain]));
-  await writeFile4(join4(dir, "stage-03-domains.json"), JSON.stringify(stage03, null, 2), "utf8");
+  await writeFile2(join2(dir, "stage-03-domains.json"), JSON.stringify(stage03, null, 2), "utf8");
   return { projectRoot, work, stack, entrypoints, fileSet, basenameIndex };
 }
 
 // ../brain/dist/pipeline/resolution.js
-import { join as join5, dirname as dirname2, relative as relative2, extname as extname2, sep as sep2 } from "path";
-import { readFile as readFile5, writeFile as writeFile5, mkdir as mkdir4 } from "fs/promises";
+import { join as join3, dirname as dirname2, relative as relative2, extname as extname2, sep as sep2 } from "path";
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 function parseJsonLenient(text) {
   const stripped = text.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
@@ -1229,12 +1197,37 @@ function parseJsonLenient(text) {
     return null;
   }
 }
+async function discoverAllTsConfigs(dir, projectRoot, maxDepth = 4) {
+  const result = {};
+  if (maxDepth < 0)
+    return result;
+  const { readdir: readdir2 } = await import("fs/promises");
+  let entries = [];
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch {
+    return result;
+  }
+  for (const entry of entries) {
+    const fullPath = join3(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name === ".git")
+        continue;
+      const sub = await discoverAllTsConfigs(fullPath, projectRoot, maxDepth - 1);
+      Object.assign(result, sub);
+    } else if (entry.name === "tsconfig.json") {
+      const paths = await extractTsConfigPaths(fullPath, projectRoot);
+      Object.assign(result, paths);
+    }
+  }
+  return result;
+}
 async function extractTsConfigPaths(tsconfigPath, projectRoot, depth = 0) {
   if (depth > 3 || !existsSync3(tsconfigPath))
     return {};
   let raw;
   try {
-    raw = await readFile5(tsconfigPath, "utf8");
+    raw = await readFile3(tsconfigPath, "utf8");
   } catch {
     return {};
   }
@@ -1243,18 +1236,31 @@ async function extractTsConfigPaths(tsconfigPath, projectRoot, depth = 0) {
     return {};
   const result = {};
   if (typeof parsed.extends === "string") {
-    const baseFile = join5(dirname2(tsconfigPath), parsed.extends);
+    let baseFile = parsed.extends;
+    if (baseFile.startsWith(".")) {
+      baseFile = join3(dirname2(tsconfigPath), baseFile);
+    } else {
+      baseFile = join3(projectRoot, "node_modules", baseFile);
+      if (!baseFile.endsWith(".json"))
+        baseFile += ".json";
+    }
     const base = await extractTsConfigPaths(baseFile, projectRoot, depth + 1);
     Object.assign(result, base);
   }
   const opts = parsed.compilerOptions || {};
-  const baseUrl = typeof opts.baseUrl === "string" ? join5(dirname2(tsconfigPath), opts.baseUrl) : dirname2(tsconfigPath);
+  const baseUrl = typeof opts.baseUrl === "string" ? join3(dirname2(tsconfigPath), opts.baseUrl) : dirname2(tsconfigPath);
+  if (typeof opts.baseUrl === "string") {
+    const relBase = relative2(projectRoot, baseUrl);
+    if (relBase && relBase !== ".") {
+      result[""] = relBase;
+    }
+  }
   const paths = opts.paths || {};
   for (const [alias, targets] of Object.entries(paths)) {
     if (!Array.isArray(targets) || targets.length === 0)
       continue;
     const first = targets[0].replace(/\/\*$/, "");
-    const resolved = relative2(projectRoot, join5(baseUrl, first));
+    const resolved = relative2(projectRoot, join3(baseUrl, first));
     const key = alias.replace(/\/\*$/, "");
     result[key] = resolved;
   }
@@ -1262,12 +1268,12 @@ async function extractTsConfigPaths(tsconfigPath, projectRoot, depth = 0) {
 }
 async function discoverWorkspacePackages(projectRoot) {
   const packages = {};
-  const pkgPath = join5(projectRoot, "package.json");
+  const pkgPath = join3(projectRoot, "package.json");
   if (!existsSync3(pkgPath))
     return packages;
   let rootPkg;
   try {
-    rootPkg = JSON.parse(await readFile5(pkgPath, "utf8"));
+    rootPkg = JSON.parse(await readFile3(pkgPath, "utf8"));
   } catch {
     return packages;
   }
@@ -1275,7 +1281,7 @@ async function discoverWorkspacePackages(projectRoot) {
   const globs = Array.isArray(workspaces) ? workspaces : Array.isArray(workspaces?.packages) ? workspaces.packages : [];
   for (const glob of globs) {
     const prefix = glob.replace(/\/\*$/, "");
-    const absPrefix = join5(projectRoot, prefix);
+    const absPrefix = join3(projectRoot, prefix);
     if (!existsSync3(absPrefix))
       continue;
     const { readdir: readdir2 } = await import("fs/promises");
@@ -1287,13 +1293,13 @@ async function discoverWorkspacePackages(projectRoot) {
       continue;
     }
     for (const entry of entries) {
-      const wsPkgPath = join5(absPrefix, entry, "package.json");
+      const wsPkgPath = join3(absPrefix, entry, "package.json");
       if (!existsSync3(wsPkgPath))
         continue;
       try {
-        const wsPkg = JSON.parse(await readFile5(wsPkgPath, "utf8"));
+        const wsPkg = JSON.parse(await readFile3(wsPkgPath, "utf8"));
         if (typeof wsPkg.name === "string") {
-          packages[wsPkg.name] = relative2(projectRoot, join5(absPrefix, entry));
+          packages[wsPkg.name] = relative2(projectRoot, join3(absPrefix, entry));
         }
       } catch {
         continue;
@@ -1302,27 +1308,6 @@ async function discoverWorkspacePackages(projectRoot) {
   }
   return packages;
 }
-async function discoverAppTsConfigPaths(projectRoot) {
-  const result = {};
-  const scanDirs = ["apps", "packages"];
-  for (const scanDir of scanDirs) {
-    const absDir = join5(projectRoot, scanDir);
-    if (!existsSync3(absDir))
-      continue;
-    const { readdir: readdir2 } = await import("fs/promises");
-    try {
-      const entries = await readdir2(absDir, { withFileTypes: true });
-      for (const entry of entries.filter((e) => e.isDirectory())) {
-        const tsconfig = join5(absDir, entry.name, "tsconfig.json");
-        const paths = await extractTsConfigPaths(tsconfig, projectRoot);
-        Object.assign(result, paths);
-      }
-    } catch {
-      continue;
-    }
-  }
-  return result;
-}
 var CONVENTIONAL_ALIASES = [
   { prefix: "~/", replacement: "" },
   { prefix: "@components/", replacement: "components/" },
@@ -1337,10 +1322,9 @@ var CONVENTIONAL_ALIASES = [
   { prefix: "@calcom/emails/", replacement: "../packages/emails/" }
 ];
 async function buildAliasMap(projectRoot) {
-  const rootPaths = await extractTsConfigPaths(join5(projectRoot, "tsconfig.json"), projectRoot);
+  const allPaths = await discoverAllTsConfigs(projectRoot, projectRoot);
   const workspacePackages = await discoverWorkspacePackages(projectRoot);
-  const appPaths = await discoverAppTsConfigPaths(projectRoot);
-  const resolvedAliases = { ...appPaths, ...rootPaths };
+  const resolvedAliases = { ...allPaths };
   for (const [pkgName, pkgDir] of Object.entries(workspacePackages)) {
     if (!(pkgName in resolvedAliases)) {
       resolvedAliases[pkgName] = pkgDir;
@@ -1355,7 +1339,7 @@ function tryJsCandidates(base, projectRoot, fileSet) {
   for (const ext of JS_EXTS)
     candidates.push(base + ext);
   for (const ext of JS_EXTS)
-    candidates.push(join5(base, "index" + ext));
+    candidates.push(join3(base, "index" + ext));
   for (const c of candidates) {
     const rel = relative2(projectRoot, c);
     if (fileSet.has(rel))
@@ -1371,11 +1355,11 @@ function resolvePython(spec, fromAbs, projectRoot, fileSet) {
     for (let i = 1; i < dots; i++)
       dir = dirname2(dir);
     const rest = spec.slice(dots).replace(/\./g, sep2);
-    modulePath = rest ? join5(dir, rest) : dir;
+    modulePath = rest ? join3(dir, rest) : dir;
   } else {
-    modulePath = join5(projectRoot, spec.replace(/\./g, sep2));
+    modulePath = join3(projectRoot, spec.replace(/\./g, sep2));
   }
-  for (const c of [modulePath + ".py", join5(modulePath, "__init__.py")]) {
+  for (const c of [modulePath + ".py", join3(modulePath, "__init__.py")]) {
     if (fileSet.has(relative2(projectRoot, c)))
       return relative2(projectRoot, c);
   }
@@ -1403,31 +1387,42 @@ function resolveImportWithAliasMap(spec, fromAbs, lang, projectRoot, fileSet, ba
   }
   if (lang === "typescript" || lang === "tsx" || lang === "javascript") {
     if (spec.startsWith(".")) {
-      const base = join5(dirname2(fromAbs), spec);
+      const base = join3(dirname2(fromAbs), spec);
       return { resolved: tryJsCandidates(base, projectRoot, fileSet), isAlias: false };
     }
     for (const [prefix, replacement] of Object.entries(aliasMap.resolvedAliases)) {
+      if (prefix === "")
+        continue;
       if (spec === prefix || spec.startsWith(prefix + "/")) {
         const rest = spec.slice(prefix.length).replace(/^\//, "");
-        const base = join5(projectRoot, replacement, rest);
+        const base = join3(projectRoot, replacement, rest);
         const resolved = tryJsCandidates(base, projectRoot, fileSet);
-        return { resolved, isAlias: true, reason: resolved ? void 0 : `alias '${prefix}' found but path '${replacement}/${rest}' not in file set` };
+        if (resolved)
+          return { resolved, isAlias: true };
       }
     }
+    if (aliasMap.resolvedAliases[""] !== void 0) {
+      const base = join3(projectRoot, aliasMap.resolvedAliases[""], spec);
+      const resolved = tryJsCandidates(base, projectRoot, fileSet);
+      if (resolved)
+        return { resolved, isAlias: true };
+    }
     for (const [pkgName, pkgDir] of Object.entries(aliasMap.workspacePackages)) {
       if (spec === pkgName || spec.startsWith(pkgName + "/")) {
         const rest = spec.slice(pkgName.length).replace(/^\//, "");
-        const base = join5(projectRoot, pkgDir, rest);
+        const base = join3(projectRoot, pkgDir, rest);
         const resolved = tryJsCandidates(base, projectRoot, fileSet);
-        return { resolved, isAlias: true, reason: resolved ? void 0 : `workspace package '${pkgName}' found but subpath '${rest}' not in file set` };
+        if (resolved)
+          return { resolved, isAlias: true };
       }
     }
     for (const { prefix, replacement } of CONVENTIONAL_ALIASES) {
       if (spec.startsWith(prefix)) {
         const rest = replacement + spec.slice(prefix.length);
-        const base = join5(projectRoot, rest);
+        const base = join3(projectRoot, rest);
         const resolved = tryJsCandidates(base, projectRoot, fileSet);
-        return { resolved, isAlias: true, reason: resolved ? void 0 : `conventional alias '${prefix}' \u2192 path not found` };
+        if (resolved)
+          return { resolved, isAlias: true };
       }
     }
     return { resolved: null, isAlias: false };
@@ -1477,8 +1472,8 @@ async function runResolution(projectRoot, inv) {
     fanOut.set(w.rel, distinctModules.size);
   }
   const unresolvedImports = [...unresolvedSet];
-  const dir = join5(projectRoot, ".vibe-splainer");
-  await mkdir4(dir, { recursive: true });
+  const dir = join3(projectRoot, ".vibe-splainer");
+  await mkdir2(dir, { recursive: true });
   const stage04 = {
     resolvedAliases: aliasMap.resolvedAliases,
     workspacePackages: aliasMap.workspacePackages,
@@ -1486,7 +1481,7 @@ async function runResolution(projectRoot, inv) {
     resolutionFailuresByFile,
     resolutionFailureReasons
   };
-  await writeFile5(join5(dir, "stage-04-aliases.json"), JSON.stringify(stage04, null, 2), "utf8");
+  await writeFile3(join3(dir, "stage-04-aliases.json"), JSON.stringify(stage04, null, 2), "utf8");
   return {
     aliasMap,
     importedBy,
@@ -1501,8 +1496,8 @@ async function runResolution(projectRoot, inv) {
 }
 
 // ../brain/dist/pipeline/classification.js
-import { join as join6, basename as basename2, extname as extname3, sep as sep3 } from "path";
-import { writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
+import { join as join4, basename as basename2, extname as extname3, sep as sep3 } from "path";
+import { writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
 function inferSideEffectProfile(source, importSpecs, productDomain, frameworkRole) {
   const effects = /* @__PURE__ */ new Set();
   if (/router\.(push|replace|back)\(|redirect\(|notFound\(|permanentRedirect\(/.test(source)) {
@@ -2111,6 +2106,8 @@ async function runClassification(projectRoot, inv, res) {
     const entrypointTraceStatus = deriveEntrypointTraceStatus(w.productDomain, runtimeEntrypoints, importsUnresolvedArr);
     const smellMaxSeverity = w.ast.smells.length > 0 ? Math.max(...w.ast.smells.map((s) => s.severity)) : 0;
     const loadBearingScore = computeLoadBearingScore(gravity, heat, fanIn, effects, w.productDomain, smellMaxSeverity, runtimeEntrypoints);
+    const isLoadBearing = fanIn >= 10;
+    const isOperationallyCritical = loadBearingScore >= 5;
     classified.push({
       rel: w.rel,
       abs: w.abs,
@@ -2135,25 +2132,28 @@ async function runClassification(projectRoot, inv, res) {
       entrypointTraceStatus,
       blockedImports: importsUnresolvedArr,
       loadBearingScore,
+      isOperationallyCritical,
+      isLoadBearing,
       hotSpans: w.ast.hotSpans,
       source: w.source
     });
   }
-  const dir = join6(projectRoot, ".vibe-splainer");
-  await mkdir5(dir, { recursive: true });
+  const dir = join4(projectRoot, ".vibe-splainer");
+  await mkdir3(dir, { recursive: true });
   const stage05 = Object.fromEntries(classified.map((f) => [f.rel, f.sideEffectProfile]));
-  await writeFile6(join6(dir, "stage-05-side-effects.json"), JSON.stringify(stage05, null, 2), "utf8");
+  await writeFile4(join4(dir, "stage-05-side-effects.json"), JSON.stringify(stage05, null, 2), "utf8");
   const stage06 = Object.fromEntries(classified.map((f) => [f.rel, f.writeIntents]));
-  await writeFile6(join6(dir, "stage-06-write-intents.json"), JSON.stringify(stage06, null, 2), "utf8");
+  await writeFile4(join4(dir, "stage-06-write-intents.json"), JSON.stringify(stage06, null, 2), "utf8");
   const stage07 = Object.fromEntries(classified.map((f) => [f.rel, f.riskTypes]));
-  await writeFile6(join6(dir, "stage-07-risk-types.json"), JSON.stringify(stage07, null, 2), "utf8");
+  await writeFile4(join4(dir, "stage-07-risk-types.json"), JSON.stringify(stage07, null, 2), "utf8");
   const stage08 = Object.fromEntries(classified.map((f) => [f.rel, {
-    isLoadBearing: f.loadBearingScore >= 5,
+    isLoadBearing: f.isLoadBearing,
+    isOperationallyCritical: f.isOperationallyCritical,
     loadBearingScore: f.loadBearingScore,
     runtimeEntrypoints: f.runtimeEntrypoints.length,
     entrypointTraceStatus: f.entrypointTraceStatus
   }]));
-  await writeFile6(join6(dir, "stage-08-load-bearing.json"), JSON.stringify(stage08, null, 2), "utf8");
+  await writeFile4(join4(dir, "stage-08-load-bearing.json"), JSON.stringify(stage08, null, 2), "utf8");
   const realClassified = classified.filter((f) => f.isRealSource).sort((a, b) => b.gravity - a.gravity);
   const wildCandidates = realClassified.filter((f) => f.heat >= 60 || f.smells.some((s) => s.severity >= 4));
   const pillars = buildPillars(classified, communities);
@@ -2171,8 +2171,8 @@ async function runClassification(projectRoot, inv, res) {
 }
 
 // ../brain/dist/pipeline/binding.js
-import { join as join7 } from "path";
-import { writeFile as writeFile7, readFile as readFile6 } from "fs/promises";
+import { join as join5 } from "path";
+import { writeFile as writeFile5, readFile as readFile4 } from "fs/promises";
 var FUNCTION_TYPES2 = /* @__PURE__ */ new Set([
   "function_declaration",
   "function_expression",
@@ -2550,7 +2550,7 @@ async function runActionBinding(projectRoot, inv, res) {
       }
     }
   }
-  await writeFile7(join7(projectRoot, ".vibe-splainer", "action_bindings.json"), JSON.stringify(artifact, null, 2), "utf8");
+  await writeFile5(join5(projectRoot, ".vibe-splainer", "action_bindings.json"), JSON.stringify(artifact, null, 2), "utf8");
   const summary = {
     filesProcessed,
     functionsExtracted,
@@ -2560,14 +2560,14 @@ async function runActionBinding(projectRoot, inv, res) {
     entrypointsFound,
     namedImportsExtracted
   };
-  await writeFile7(join7(projectRoot, ".vibe-splainer", "stage-09-action-bindings-summary.json"), JSON.stringify(summary, null, 2), "utf8");
+  await writeFile5(join5(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");
+  const artifactPath = join5(projectRoot, ".vibe-splainer", "action_bindings.json");
   let artifact;
   try {
-    const raw = await readFile6(artifactPath, "utf8");
+    const raw = await readFile4(artifactPath, "utf8");
     artifact = JSON.parse(raw);
   } catch {
     throw new Error("action_bindings.json not found. Run scan_project first.");
@@ -2690,9 +2690,8 @@ async function traverseCallChain(projectRoot, args) {
 }
 
 // ../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";
+import { join as join6 } from "path";
+import { mkdir as mkdir4, readFile as readFile5 } from "fs/promises";
 function computeSeverity(sideEffectProfile, productDomain, gravity, heat, maxNesting, hasLongFunctions, swallowedCatches, runtimeEntrypoints) {
   let score = 0;
   if (sideEffectProfile.includes("database_write"))
@@ -2759,149 +2758,6 @@ function applyCorrections(file) {
     file.canonicalLoadBearing = true;
   }
 }
-function inferObservableOutputs(frameworkRole, productDomain, sideEffectProfile) {
-  const outputs = [];
-  const ENTRYPOINT_ROLES2 = /* @__PURE__ */ new Set(["app_route_page", "app_route_handler", "pages_route", "pages_api_route", "trpc_api_route"]);
-  if (sideEffectProfile.includes("redirect"))
-    outputs.push("redirect_url");
-  if (ENTRYPOINT_ROLES2.has(frameworkRole))
-    outputs.push("http_status");
-  if (frameworkRole === "app_route_handler" || frameworkRole === "pages_api_route") {
-    outputs.push("json_response_shape");
-  }
-  if (productDomain === "booking_creation" || productDomain === "booking_management")
-    outputs.push("booking_uid");
-  if (productDomain === "payments" || productDomain === "payments_webhooks")
-    outputs.push("payment_status");
-  if (productDomain === "auth_oauth")
-    outputs.push("auth_token");
-  if (sideEffectProfile.includes("webhook_delivery") || sideEffectProfile.includes("webhook_ingress")) {
-    outputs.push("webhook_payload");
-  }
-  if (sideEffectProfile.includes("calendar_mutation"))
-    outputs.push("calendar_event_id");
-  if (sideEffectProfile.includes("email_send"))
-    outputs.push("email_payload");
-  if (sideEffectProfile.includes("analytics_event"))
-    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) {
-  if (loadBearingScore >= 12 || productDomain === "booking_creation" && riskTypes.includes("mutation_orchestration")) {
-    return {
-      level: "critical",
-      reason: `${productDomain} domain with ${riskTypes.join(", ")} \u2014 any patch risks breaking live booking, payment, or auth flows.`
-    };
-  }
-  if (loadBearingScore >= 8 || sideEffectProfile.includes("payment_mutation") || sideEffectProfile.includes("auth_token_mutation")) {
-    const external = sideEffectProfile.filter((s) => ["payment_mutation", "auth_token_mutation", "database_write", "webhook_delivery"].includes(s));
-    return {
-      level: "high",
-      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) {
-  if (riskTypes.includes("mutation_orchestration")) {
-    return "Do not rewrite inline. Extract pure decision logic into a tested reducer or state machine first. Preserve all side-effect call sites (redirect URLs, SDK event names, response shapes) as invariants.";
-  }
-  if (riskTypes.includes("registry_bottleneck")) {
-    return "Add new entries without removing existing keys. Treat the registry map as append-only until all consumers are verified.";
-  }
-  if (riskTypes.includes("registry_consumer")) {
-    return "Verify the registry contract (Components.tsx) before patching. Changes to field types must be reflected in both the registry and all rendering paths.";
-  }
-  if (riskTypes.includes("route_handler_write_path")) {
-    return "Add integration tests covering success and failure paths before modifying. Verify HTTP status codes and response shapes are preserved.";
-  }
-  if (riskTypes.includes("god_component") || riskTypes.includes("god_hook")) {
-    return "Extract sub-concerns into separate modules first. Only refactor the extraction points after tests confirm equivalence.";
-  }
-  if (sideEffectProfile.includes("database_write")) {
-    return "Wrap changes in a transaction or use a feature flag. Run against a staging database before production.";
-  }
-  return "Review importedBy before patching. Run affected integration tests.";
-}
-function inferDoNotTouch(sideEffectProfile, productDomain) {
-  const items = [];
-  if (sideEffectProfile.includes("payment_mutation"))
-    items.push("payment flow branch");
-  if (sideEffectProfile.includes("auth_token_mutation"))
-    items.push("token issuance / refresh branch");
-  if (sideEffectProfile.includes("webhook_delivery") || sideEffectProfile.includes("webhook_ingress")) {
-    items.push("webhook payload shape");
-  }
-  if (sideEffectProfile.includes("redirect"))
-    items.push("redirect URL strings");
-  if (sideEffectProfile.includes("analytics_event"))
-    items.push("SDK event names");
-  if (sideEffectProfile.includes("booking_mutation")) {
-    items.push("booking success response shape", "recurring booking branch");
-  }
-  if (productDomain === "auth_oauth")
-    items.push("OAuth callback URLs", "token scopes");
-  return items;
-}
-function inferTestProbes(writeIntents, observableOutputs) {
-  const probes = [];
-  if (writeIntents.includes("create_booking")) {
-    probes.push({
-      name: "standard booking success",
-      scenario: "create a standard booking and assert success redirect and booking uid",
-      expectedObservable: ["booking_uid", "redirect_url", "sdk_event_name"].filter((o) => observableOutputs.includes(o))
-    });
-  }
-  if (writeIntents.includes("reschedule_booking")) {
-    probes.push({
-      name: "reschedule booking",
-      scenario: "reschedule an existing booking and assert reschedule event path",
-      expectedObservable: ["booking_uid", "redirect_url"].filter((o) => observableOutputs.includes(o))
-    });
-  }
-  if (writeIntents.includes("create_recurring_booking")) {
-    probes.push({
-      name: "recurring booking",
-      scenario: "create recurring booking and assert recurring success behavior",
-      expectedObservable: ["booking_uid", "redirect_url"].filter((o) => observableOutputs.includes(o))
-    });
-  }
-  if (writeIntents.includes("handle_payment_webhook")) {
-    probes.push({
-      name: "payment webhook ingestion",
-      scenario: "send a valid payment webhook and assert booking/payment state updated",
-      expectedObservable: ["payment_status", "booking_uid", "http_status"].filter((o) => observableOutputs.includes(o))
-    });
-  }
-  if (writeIntents.includes("issue_auth_token")) {
-    probes.push({
-      name: "token issuance",
-      scenario: "complete OAuth flow and assert access token issued with correct scopes",
-      expectedObservable: ["auth_token", "http_status"].filter((o) => observableOutputs.includes(o))
-    });
-  }
-  return probes;
-}
 function deriveConfidence(fanIn, gravity) {
   if (fanIn >= 10 && gravity >= 40)
     return "high";
@@ -2910,12 +2766,12 @@ function deriveConfidence(fanIn, gravity) {
   return "low";
 }
 async function runScoring(projectRoot, cr, binding) {
-  const dir = join8(projectRoot, ".vibe-splainer");
-  await mkdir6(dir, { recursive: true });
+  const dir = join6(projectRoot, ".vibe-splainer");
+  await mkdir4(dir, { recursive: true });
   let bindingArtifact = binding?.artifact;
   if (!bindingArtifact) {
     try {
-      const raw = await readFile7(join8(projectRoot, ".vibe-splainer", "action_bindings.json"), "utf8");
+      const raw = await readFile5(join6(projectRoot, ".vibe-splainer", "action_bindings.json"), "utf8");
       bindingArtifact = JSON.parse(raw);
     } catch {
     }
@@ -2924,7 +2780,7 @@ async function runScoring(projectRoot, cr, binding) {
   const severityBreakdowns = {};
   for (const f of cr.classified) {
     const severity = computeSeverity(f.sideEffectProfile, f.productDomain, f.gravity, f.heat, f.heatSignals.maxNesting, f.heatSignals.longFunctions > 0, f.heatSignals.swallowedCatches, f.runtimeEntrypoints);
-    const isLoadBearing = f.loadBearingScore >= 5;
+    const confidence = deriveConfidence(f.gravitySignals.fanIn, f.gravity);
     const pf = {
       relativePath: f.rel,
       language: f.lang,
@@ -2946,161 +2802,25 @@ async function runScoring(projectRoot, cr, binding) {
       riskTypes: f.riskTypes,
       writeIntents: f.writeIntents,
       canonicalSeverity: severity,
-      canonicalLoadBearing: isLoadBearing
+      canonicalLoadBearing: f.isLoadBearing,
+      // STRICT: fanIn >= 10
+      isOperationallyCritical: f.isOperationallyCritical,
+      confidence
     };
     applyCorrections(pf);
     persisted[f.rel] = pf;
     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 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)) {
-    importedByMapForDelta.set(rel, new Set(pf.importedBy));
-  }
-  const metaForDelta = new Map(Object.entries(persisted).map(([rel, pf]) => [rel, { frameworkRole: pf.frameworkRole, productDomain: pf.productDomain }]));
-  const deltaTargets = Object.values(persisted).filter((pf) => pf.isRealSource).sort((a, b) => b.gravity - a.gravity).map((pf) => {
-    const runtimeEntrypoints = findRuntimeEntrypoints(pf.relativePath, importedByMapForDelta, metaForDelta);
-    const entrypointTraceStatus = deriveEntrypointTraceStatus(pf.productDomain, runtimeEntrypoints, pf.importsUnresolved);
-    const smellMaxSeverity = pf.smells.length > 0 ? Math.max(...pf.smells.map((s) => s.severity)) : 0;
-    const loadBearingScore = computeLoadBearingScore(pf.gravity, pf.heat, pf.importedBy.length, pf.sideEffectProfile, pf.productDomain, smellMaxSeverity, runtimeEntrypoints);
-    const observableOutputs = inferObservableOutputs(pf.frameworkRole, pf.productDomain, pf.sideEffectProfile);
-    const patchRisk = inferPatchRisk(pf.productDomain, pf.riskTypes, pf.sideEffectProfile, pf.importedBy.length, loadBearingScore);
-    const confidence = deriveConfidence(pf.gravitySignals.fanIn, pf.gravity);
-    const fileHashInput = pf.hotSpans.map((h) => h.snippet).join("");
-    const fileHash = createHash("sha256").update(fileHashInput || pf.relativePath).digest("hex").slice(0, 12);
-    const rawEvidence = pf.hotSpans.map((span) => ({
-      file: pf.relativePath,
-      startLine: span.startLine,
-      endLine: span.endLine,
-      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`);
-          } else if (fn.calls.length > 0) {
-            fnScore += 1;
-            reasons.push(`Has ${fn.calls.length} 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");
-          }
-          const hasEvidenceOverlap = rawEvidence.some((e) => fn.startLine <= e.endLine && fn.endLine >= e.startLine);
-          if (hasEvidenceOverlap) {
-            fnScore += 2;
-            reasons.push("Overlaps with raw evidence span");
-          }
-          return { fn, fnScore, reasons };
-        });
-        scoredFunctions.sort((a, b) => b.fnScore - a.fnScore);
-        const topFns = scoredFunctions.filter((x) => x.reasons.length > 0).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,
-      productDomain: pf.productDomain,
-      gravity: Math.round(pf.gravity),
-      heat: Math.round(pf.heat),
-      severity: pf.canonicalSeverity,
-      confidence,
-      isLoadBearing: pf.canonicalLoadBearing || loadBearingScore >= 5,
-      loadBearingScore,
-      riskTypes: pf.riskTypes,
-      sideEffectProfile: pf.sideEffectProfile,
-      blastRadius: pf.importedBy,
-      runtimeEntrypoints,
-      entrypointTraceStatus,
-      blockedImports: pf.importsUnresolved,
-      observableOutputs,
-      writeIntents: pf.writeIntents,
-      patchRisk,
-      safePatchStrategy: inferSafePatchStrategy(pf.riskTypes, pf.sideEffectProfile),
-      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 = join8(dir, "delta_targets.json");
-  const tmp = dest + ".tmp";
-  await writeFile8(tmp, JSON.stringify(deltaTargets, null, 2), "utf8");
-  const { rename } = await import("fs/promises");
-  await rename(tmp, dest);
-  const validationReport = await buildValidationReport(store, deltaTargets, projectRoot);
-  await writeFile8(join8(dir, "validation_report.json"), JSON.stringify(validationReport, null, 2), "utf8");
+  const deltaTargets = Object.values(persisted).filter((pf) => pf.isRealSource).sort((a, b) => b.gravity - a.gravity).map((pf) => ({
+    path: pf.relativePath,
+    gravity: Math.round(pf.gravity),
+    isLoadBearing: pf.canonicalLoadBearing,
+    // STRICT: fanIn >= 10
+    blastRadius: pf.importedBy,
+    pillarHint: pf.pillarHint
+  }));
+  const validationReport = await buildValidationReport(store, deltaTargets, projectRoot, cr);
   for (const e of validationReport.errors) {
     console.error(`[vibe-splain] VALIDATION ERROR [${e.rule}] ${e.file}: ${e.detail}`);
   }
@@ -3109,24 +2829,27 @@ async function runScoring(projectRoot, cr, binding) {
   }
   return { store, deltaTargets, validationReport };
 }
-async function buildValidationReport(store, deltaTargets, projectRoot) {
+async function buildValidationReport(store, deltaTargets, projectRoot, cr) {
   const errors = [];
   const warnings = [];
   let passCount = 0;
-  const deltaByPath = new Map(deltaTargets.map((d) => [d.path, d]));
+  let tracedCount = 0;
+  let realCount = 0;
   for (const [, pf] of Object.entries(store.files)) {
     if (!pf.isRealSource)
       continue;
-    const delta = deltaByPath.get(pf.relativePath);
-    if (pf.canonicalSeverity === 5 && !pf.canonicalLoadBearing) {
-      errors.push({
-        file: pf.relativePath,
-        rule: "severity_5_not_load_bearing",
-        detail: "severity=5 but canonicalLoadBearing=false \u2014 post-correction invariant violated",
-        expected: "canonicalLoadBearing=true",
-        actual: "canonicalLoadBearing=false"
-      });
-      continue;
+    realCount++;
+    const classified = cr.classified.find((f) => f.rel === pf.relativePath);
+    if (classified && classified.entrypointTraceStatus === "complete")
+      tracedCount++;
+    if (pf.canonicalSeverity === 5 && !pf.canonicalLoadBearing && pf.gravitySignals.fanIn < 10) {
+      if (!pf.isOperationallyCritical) {
+        errors.push({
+          file: pf.relativePath,
+          rule: "severity_5_no_criticality",
+          detail: "severity=5 but not load-bearing and not operationally critical"
+        });
+      }
     }
     if (pf.writeIntents.includes("handle_payment_webhook") && pf.sideEffectProfile.includes("none_detected")) {
       errors.push({
@@ -3138,7 +2861,7 @@ async function buildValidationReport(store, deltaTargets, projectRoot) {
       });
       continue;
     }
-    if (pf.productDomain === "booking_creation" && delta?.entrypointTraceStatus === "no_runtime_entrypoint_found" && pf.importsUnresolved.length === 0) {
+    if (pf.productDomain === "booking_creation" && classified?.entrypointTraceStatus === "no_runtime_entrypoint_found" && pf.importsUnresolved.length === 0) {
       errors.push({
         file: pf.relativePath,
         rule: "booking_creation_no_entrypoint_no_blockers",
@@ -3146,72 +2869,29 @@ async function buildValidationReport(store, deltaTargets, projectRoot) {
       });
       continue;
     }
-    if (delta && delta.severity !== pf.canonicalSeverity) {
-      errors.push({
-        file: pf.relativePath,
-        rule: "severity_mismatch_delta",
-        detail: "DeltaTarget severity does not match canonicalSeverity",
-        expected: String(pf.canonicalSeverity),
-        actual: String(delta.severity)
-      });
-      continue;
-    }
-    if (pf.canonicalSeverity >= 4 && (delta?.rawEvidence.length ?? 0) === 0 && pf.hotSpans.length === 0) {
+    if (pf.canonicalSeverity >= 4 && pf.hotSpans.length === 0) {
       errors.push({
         file: pf.relativePath,
         rule: "high_severity_no_evidence",
-        detail: `severity=${pf.canonicalSeverity} but rawEvidence is empty`
+        detail: `severity=${pf.canonicalSeverity} but no evidence hotSpans found`
       });
       continue;
     }
-    if (pf.canonicalSeverity >= 4 && (delta?.runtimeEntrypoints.length ?? 0) === 0) {
+    if (pf.canonicalSeverity >= 4 && (classified?.runtimeEntrypoints.length ?? 0) === 0) {
       warnings.push({
         file: pf.relativePath,
         rule: "high_severity_no_entrypoints",
         detail: `severity=${pf.canonicalSeverity} but no runtime entrypoints found \u2014 check alias resolution`
       });
     }
-    if (delta?.entrypointTraceStatus === "partial_wrong_surface") {
-      const foundPaths = delta.runtimeEntrypoints.map((e) => e.path).join(", ");
+    if (classified?.entrypointTraceStatus === "partial_wrong_surface") {
+      const foundPaths = classified.runtimeEntrypoints.map((e) => e.path).join(", ");
       warnings.push({
         file: pf.relativePath,
         rule: "partial_wrong_surface",
         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"];
@@ -3236,45 +2916,38 @@ async function buildValidationReport(store, deltaTargets, projectRoot) {
     let secondaryTrigger = false;
     if (!primaryTrigger && pf.productDomain !== "payments_webhooks") {
       try {
-        const src = await readFile7(join8(projectRoot, rel), "utf8");
+        const src = await readFile5(join6(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`
+        `Payment webhook not classified as payments_webhooks`
       ],
       [
         !pf.sideEffectProfile.includes("webhook_ingress"),
         "webhook_ingress_missing",
-        `Payment webhook (${triggerLabel} trigger) missing webhook_ingress side effect`
+        `Payment webhook missing webhook_ingress side effect`
       ],
       [
         !pf.sideEffectProfile.includes("payment_mutation"),
         "webhook_payment_mutation_missing",
-        `Payment webhook (${triggerLabel} trigger) missing payment_mutation side effect`
+        `Payment webhook 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`
+        `Payment webhook 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`
+        !pf.isOperationallyCritical,
+        "webhook_criticality",
+        `Payment webhook must be operationally critical`
       ]
     ];
     for (const [condition, rule, detail] of webhookChecks) {
@@ -3282,12 +2955,13 @@ async function buildValidationReport(store, deltaTargets, projectRoot) {
         errors.push({ file: rel, rule, detail });
     }
   }
+  const coverage = realCount > 0 ? Math.round(tracedCount / realCount * 100) : 0;
   return {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     passed: errors.length === 0,
     errors,
     warnings,
-    summary: { errorCount: errors.length, warningCount: warnings.length, passCount }
+    summary: { errorCount: errors.length, warningCount: warnings.length, passCount, entrypointTraceCoverage: coverage }
   };
 }
 
@@ -3298,8 +2972,6 @@ async function runPipeline(projectRoot) {
   const binding = await runActionBinding(projectRoot, inv, res);
   const cr = await runClassification(projectRoot, inv, res);
   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) => ({
     path: f.abs,
     relativePath: f.rel,
@@ -3332,7 +3004,7 @@ async function runPipeline(projectRoot) {
     productDomain: f.productDomain,
     sideEffectProfile: f.sideEffectProfile
   }));
-  const uiUrl = `file://${join9(projectRoot, ".vibe-splainer", "ui", "index.html")}`;
+  const uiUrl = `file://${join7(projectRoot, ".vibe-splainer", "ui", "index.html")}`;
   return {
     projectRoot,
     totalFilesScanned: cr.classified.length,
@@ -3342,6 +3014,7 @@ async function runPipeline(projectRoot) {
     wildCandidates,
     uiUrl,
     graph: res.graph,
+    store: scoring.store,
     validation: {
       passed: scoring.validationReport.passed,
       errors: scoring.validationReport.summary.errorCount,
@@ -3365,7 +3038,7 @@ async function getFileAnalysis(absPath) {
     return null;
   let source;
   try {
-    source = await readFile8(absPath, "utf8");
+    source = await readFile6(absPath, "utf8");
   } catch {
     return null;
   }
@@ -3402,56 +3075,30 @@ async function getFileAnalysis(absPath) {
   };
 }
 
-// ../brain/dist/dossier.js
-import { Mutex } from "async-mutex";
-import { join as join10, dirname as dirname3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-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 = join10(projectRoot, ".vibe-splainer", "dossier.json");
+// ../brain/dist/analysis.js
+import { join as join8 } from "path";
+import { readFile as readFile7, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
+async function readAnalysis(projectRoot) {
+  const p = join8(projectRoot, ".vibe-splainer", "analysis.json");
   try {
-    const raw = await readFile9(dossierPath, "utf8");
+    const raw = await readFile7(p, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
-async function writeDossier(projectRoot, dossier) {
-  await dossierMutex.runExclusive(async () => {
-    for (const p of dossier.pillars) {
-      p.decisions = p.decisions.filter((c) => !(c.severity === 1 && c.category === "Convention"));
-      p.cardCount = p.decisions.length;
-    }
-    const dir = join10(projectRoot, ".vibe-splainer");
-    await mkdir7(dir, { recursive: true });
-    const dossierPath = join10(dir, "dossier.json");
-    const tmp = dossierPath + ".tmp";
-    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 = join10(projectRoot, ".vibe-splainer", "ui");
-  await mkdir7(uiDir, { recursive: true });
-  let templateDir = join10(__dirname2, "ui");
-  if (!existsSync4(templateDir)) {
-    templateDir = join10(__dirname2, "../../cli/dist/ui");
-  }
-  if (!existsSync4(templateDir)) {
-    console.error("[vibe-splain] UI template not found at", templateDir, "- skipping UI regeneration");
-    return;
+
+// ../brain/dist/dossier.js
+import { join as join9 } from "path";
+import { readFile as readFile8 } from "fs/promises";
+async function readDossier(projectRoot) {
+  const dossierPath = join9(projectRoot, ".vibe-splainer", "dossier.json");
+  try {
+    const raw = await readFile8(dossierPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
   }
-  cpSync(templateDir, uiDir, { recursive: true });
-  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 writeFile9(join10(uiDir, "index.html"), html, "utf8");
-  console.error("[vibe-splain] UI regenerated at", join10(uiDir, "index.html"));
 }
 function validateMermaidNodeCount(diagram) {
   if (!diagram)
@@ -3468,11 +3115,452 @@ function validateMermaidNodeCount(diagram) {
   return nodes.size <= 7;
 }
 
-// ../brain/dist/watcher.js
+// ../brain/dist/policy/RecommendationEngine.js
+function getEffortValue(effort) {
+  if (effort === "low")
+    return 1;
+  if (effort === "medium")
+    return 2;
+  return 3;
+}
+function getImpactValue(impact) {
+  if (impact === "low")
+    return 1;
+  if (impact === "medium")
+    return 2;
+  return 3;
+}
+var RecommendationEngine = class {
+  static generateRecommendations(file) {
+    const recommendations = [];
+    if (file.riskTypes.includes("mutation_orchestration")) {
+      recommendations.push({
+        strategy: "Extract Decision Logic",
+        description: "Do not rewrite inline. Extract pure decision logic into a tested reducer or state machine first. Preserve all side-effect call sites (redirect URLs, SDK event names, response shapes) as invariants.",
+        effort: "high",
+        impact: "high"
+      });
+    }
+    if (file.riskTypes.includes("registry_bottleneck")) {
+      recommendations.push({
+        strategy: "Append-Only Registry Updates",
+        description: "Add new entries without removing existing keys. Treat the registry map as append-only until all consumers are verified.",
+        effort: "low",
+        impact: "medium"
+      });
+    }
+    if (file.riskTypes.includes("registry_consumer")) {
+      recommendations.push({
+        strategy: "Verify Registry Contract",
+        description: "Verify the registry contract before patching. Changes to field types must be reflected in both the registry and all rendering paths.",
+        effort: "medium",
+        impact: "low"
+      });
+    }
+    if (file.riskTypes.includes("route_handler_write_path")) {
+      recommendations.push({
+        strategy: "Integration Testing First",
+        description: "Add integration tests covering success and failure paths before modifying. Verify HTTP status codes and response shapes are preserved.",
+        effort: "medium",
+        impact: "high"
+      });
+    }
+    if (file.riskTypes.includes("god_component") || file.riskTypes.includes("god_hook")) {
+      recommendations.push({
+        strategy: "Extract Sub-Concerns",
+        description: "Extract sub-concerns into separate modules first. Only refactor the extraction points after tests confirm equivalence.",
+        effort: "high",
+        impact: "high"
+      });
+    }
+    if (file.sideEffectProfile.includes("database_write")) {
+      recommendations.push({
+        strategy: "Feature Flags & Staging",
+        description: "Wrap changes in a transaction or use a feature flag. Run against a staging database before production.",
+        effort: "medium",
+        impact: "high"
+      });
+    }
+    if (recommendations.length === 0 && file.importedBy.length >= 5) {
+      recommendations.push({
+        strategy: "Review Blast Radius",
+        description: "Review importedBy before patching. Run affected integration tests.",
+        effort: "medium",
+        impact: "medium"
+      });
+    }
+    recommendations.sort((a, b) => {
+      const ratioA = getImpactValue(a.impact) / getEffortValue(a.effort);
+      const ratioB = getImpactValue(b.impact) / getEffortValue(b.effort);
+      return ratioB - ratioA;
+    });
+    return recommendations;
+  }
+};
+
+// dist/export/ArtifactBundleWriter.js
+import { join as join10 } from "path";
+import { writeFile as writeFile7, mkdir as mkdir6, rm, rename } from "fs/promises";
+import { createHash } from "crypto";
+var ArtifactBundleWriter = class {
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  async writeBundle(artifacts) {
+    const outputDir = join10(this.projectRoot, ".vibe-splainer");
+    const stagingDir = join10(this.projectRoot, ".vibe-splainer.tmp");
+    try {
+      await rm(stagingDir, { recursive: true, force: true });
+      const { existsSync: existsSync5 } = await import("fs");
+      const { cp } = await import("fs/promises");
+      if (existsSync5(outputDir)) {
+        await cp(outputDir, stagingDir, { recursive: true });
+      } else {
+        await mkdir6(stagingDir, { recursive: true });
+      }
+      const manifestArtifacts = [];
+      for (const artifact of artifacts) {
+        const destPath = join10(stagingDir, artifact.path);
+        await mkdir6(join10(destPath, ".."), { recursive: true });
+        await writeFile7(destPath, artifact.content);
+        const contentStr = artifact.content;
+        const buffer = typeof contentStr === "string" ? Buffer.from(contentStr, "utf-8") : contentStr;
+        manifestArtifacts.push({
+          type: artifact.type,
+          path: artifact.path,
+          checksum: "sha256:" + createHash("sha256").update(buffer).digest("hex"),
+          sizeBytes: buffer.length
+        });
+      }
+      const manifest = {
+        schemaVersion: "1.0.0",
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        projectRoot: this.projectRoot,
+        artifacts: manifestArtifacts
+      };
+      await writeFile7(join10(stagingDir, "artifact_manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+      await rm(outputDir, { recursive: true, force: true });
+      await rename(stagingDir, outputDir);
+    } catch (err) {
+      await rm(stagingDir, { recursive: true, force: true });
+      throw err;
+    }
+  }
+};
+
+// dist/export/renderers/JsonRenderer.js
+var JsonRenderer = class {
+  render(viewModel, _store) {
+    return [
+      {
+        type: "dossier",
+        path: "dossier.json",
+        content: JSON.stringify(viewModel, null, 2)
+      }
+    ];
+  }
+};
+
+// dist/export/renderers/HtmlRenderer.js
+import { join as join11, dirname as dirname3, relative as relative3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { existsSync as existsSync4, readFileSync, readdirSync, statSync } from "fs";
+var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+function getAllFiles(dirPath, arrayOfFiles = []) {
+  const files = readdirSync(dirPath);
+  files.forEach(function(file) {
+    const fullPath = join11(dirPath, file);
+    if (statSync(fullPath).isDirectory()) {
+      arrayOfFiles = getAllFiles(fullPath, arrayOfFiles);
+    } else {
+      arrayOfFiles.push(fullPath);
+    }
+  });
+  return arrayOfFiles;
+}
+var HtmlRenderer = class {
+  render(viewModel, _store) {
+    let templateDir = join11(__dirname2, "..", "..", "ui");
+    if (!existsSync4(templateDir)) {
+      templateDir = join11(__dirname2, "..", "..", "..", "..", "dist", "ui");
+    }
+    if (!existsSync4(templateDir)) {
+      console.error("[vibe-splain] UI template not found at", templateDir, "- skipping UI regeneration");
+      return [];
+    }
+    const artifacts = [];
+    const allFiles = getAllFiles(templateDir);
+    for (const file of allFiles) {
+      const relPath = relative3(templateDir, file);
+      if (relPath === "index.html") {
+        const templateHtml = readFileSync(file, "utf8");
+        const injection = `<script>window.__VIBE_DOSSIER__ = ${JSON.stringify(viewModel)};</script>`;
+        const bakedHtml = templateHtml.replace("<!-- VIBE_DOSSIER_INJECTION_POINT -->", injection);
+        artifacts.push({
+          type: "html",
+          path: join11("ui", relPath),
+          content: bakedHtml
+        });
+      } else {
+        artifacts.push({
+          type: "asset",
+          path: join11("ui", relPath),
+          content: readFileSync(file)
+        });
+      }
+    }
+    return artifacts;
+  }
+};
+
+// dist/export/renderers/DeltaRenderer.js
+var DeltaRenderer = class {
+  render(_viewModel, store) {
+    const deltaTargets = Object.values(store.files).filter((pf) => pf.isRealSource).sort((a, b) => b.gravity - a.gravity).map((pf) => ({
+      path: pf.relativePath,
+      gravity: Math.round(pf.gravity),
+      isLoadBearing: pf.canonicalLoadBearing,
+      blastRadius: pf.importedBy,
+      pillarHint: pf.pillarHint
+    }));
+    return [
+      {
+        type: "delta",
+        path: "delta_targets.json",
+        content: JSON.stringify(deltaTargets, null, 2)
+      }
+    ];
+  }
+};
+
+// dist/export/renderers/AgentMarkdownRenderer.js
+var AgentMarkdownRenderer = class {
+  budget;
+  constructor(budget = 8e3) {
+    this.budget = budget;
+  }
+  render(viewModel, store) {
+    let md = `# Architectural Dossier: ${viewModel.projectRoot}
+
+`;
+    if (viewModel.map.brief) {
+      md += `## Project Brief
+${viewModel.map.brief}
+
+`;
+    }
+    md += `## Stack & Entrypoints
+`;
+    md += `- Stack: ${viewModel.map.stack.join(", ")}
+`;
+    md += `- Entrypoints: ${viewModel.map.entrypoints.join(", ")}
+
+`;
+    const allDecisions = viewModel.pillars.flatMap((p) => p.decisions).concat(viewModel.wildDiscoveries);
+    const uniqueDecisions = /* @__PURE__ */ new Map();
+    for (const d of allDecisions) {
+      if (d.primaryFile && !uniqueDecisions.has(d.primaryFile)) {
+        uniqueDecisions.set(d.primaryFile, d);
+      }
+    }
+    const tier1 = [];
+    const tier2 = [];
+    const tier3 = [];
+    const sortedFiles = Object.values(store.files).filter((f) => f.isRealSource).sort((a, b) => b.gravity - a.gravity);
+    for (const f of sortedFiles) {
+      const card = uniqueDecisions.get(f.relativePath);
+      const isCritical = card && card.severity >= 4;
+      if (f.gravity >= 70 || isCritical) {
+        tier1.push(f.relativePath);
+      } else if (f.gravity >= 40 || card) {
+        tier2.push(f.relativePath);
+      } else {
+        tier3.push(f.relativePath);
+      }
+    }
+    md += `## Tier 1: Critical Files & Risks
+
+`;
+    for (const path of tier1) {
+      const f = store.files[path];
+      const card = uniqueDecisions.get(path);
+      const recs = viewModel.recommendations[path] || [];
+      md += `### ${path}
+`;
+      md += `- Gravity: ${Math.round(f.gravity)} | Heat: ${Math.round(f.heat)}
+`;
+      md += `- Domain: ${f.productDomain} | Role: ${f.frameworkRole}
+`;
+      if (card) {
+        md += `
+**Verdict**: ${card.thesis}
+`;
+        md += `**Severity**: ${card.severity} | **Category**: ${card.category}
+`;
+        md += `**Narrative**: ${card.narrative}
+`;
+      }
+      if (recs.length > 0) {
+        md += `
+**Safe Patch Strategies**:
+`;
+        for (const r of recs) {
+          md += `- **${r.strategy}**: ${r.description}
+`;
+        }
+      }
+      md += `
+---
+
+`;
+    }
+    md += `## Tier 2: Important Files
+
+`;
+    for (const path of tier2) {
+      const f = store.files[path];
+      const card = uniqueDecisions.get(path);
+      md += `- **${path}** (Gravity: ${Math.round(f.gravity)})`;
+      if (card) {
+        md += ` \u2014 ${card.thesis}`;
+      }
+      md += `
+`;
+    }
+    md += `
+`;
+    md += `## Tier 3: Index
+
+`;
+    for (const path of tier3) {
+      const f = store.files[path];
+      md += `- ${path} (Gravity: ${Math.round(f.gravity)})
+`;
+    }
+    return [
+      {
+        type: "markdown",
+        path: "dossier.agent.md",
+        content: md
+      }
+    ];
+  }
+};
+
+// dist/export/renderers/ValidationRenderer.js
+var ValidationRenderer = class {
+  render(viewModel, _store) {
+    if (!viewModel.map.validation)
+      return [];
+    return [
+      {
+        type: "validation",
+        path: "validation_report.json",
+        content: JSON.stringify(viewModel.map.validation, null, 2)
+      }
+    ];
+  }
+};
+
+// dist/export/renderers/RawAnalysisRenderer.js
+var RawAnalysisRenderer = class {
+  render(_viewModel, store) {
+    return [
+      {
+        type: "analysis",
+        path: "analysis.json",
+        content: JSON.stringify(store, null, 2)
+      }
+    ];
+  }
+};
+
+// dist/export/renderers/GraphRenderer.js
+var GraphRenderer = class {
+  graph;
+  constructor(graph) {
+    this.graph = graph;
+  }
+  render(_viewModel, _store) {
+    if (!this.graph)
+      return [];
+    return [
+      {
+        type: "graph",
+        path: "graph.json",
+        content: JSON.stringify(this.graph, null, 2)
+      }
+    ];
+  }
+};
+
+// dist/export/ExportOrchestrator.js
+var ExportOrchestrator = class {
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  async writeBundle(dossier, options = {}, store, graph) {
+    const finalStore = store || await readAnalysis(this.projectRoot);
+    if (!finalStore) {
+      throw new Error("Analysis store not found. Scan the project first.");
+    }
+    for (const p of dossier.pillars) {
+      p.decisions = p.decisions.filter((c) => !(c.severity === 1 && c.category === "Convention"));
+      p.cardCount = p.decisions.length;
+    }
+    const viewModel = this.buildViewModel(dossier, finalStore);
+    const artifacts = [];
+    artifacts.push(...await new JsonRenderer().render(viewModel, finalStore));
+    artifacts.push(...await new DeltaRenderer().render(viewModel, finalStore));
+    artifacts.push(...await new ValidationRenderer().render(viewModel, finalStore));
+    artifacts.push(...await new RawAnalysisRenderer().render(viewModel, finalStore));
+    if (graph) {
+      artifacts.push(...await new GraphRenderer(graph).render(viewModel, finalStore));
+    }
+    const formats = ["html", "markdown"];
+    if (options.format && options.format !== "json" && options.format !== "delta") {
+      formats.length = 0;
+      formats.push(options.format);
+    }
+    if (formats.includes("html")) {
+      artifacts.push(...await new HtmlRenderer().render(viewModel, finalStore));
+    }
+    if (formats.includes("markdown")) {
+      artifacts.push(...await new AgentMarkdownRenderer(options.budget).render(viewModel, finalStore));
+    }
+    const writer = new ArtifactBundleWriter(this.projectRoot);
+    await writer.writeBundle(artifacts);
+  }
+  buildViewModel(dossier, store) {
+    const recommendations = {};
+    for (const file of dossier.map.topGravity) {
+      const persisted = store.files[file];
+      if (persisted) {
+        recommendations[file] = RecommendationEngine.generateRecommendations(persisted);
+      }
+    }
+    for (const file of dossier.map.topHeat) {
+      if (!recommendations[file]) {
+        const persisted = store.files[file];
+        if (persisted) {
+          recommendations[file] = RecommendationEngine.generateRecommendations(persisted);
+        }
+      }
+    }
+    return {
+      ...dossier,
+      recommendations
+    };
+  }
+};
+
+// dist/export/Watcher.js
 import chokidar from "chokidar";
 import { createHash as createHash2 } from "crypto";
-import { readFile as readFile10 } from "fs/promises";
-import { join as join11 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join12 } from "path";
 function startWatcher(projectRoot, watchedPaths) {
   const watcher = chokidar.watch(watchedPaths.length > 0 ? watchedPaths : projectRoot, {
     ignoreInitial: true,
@@ -3484,14 +3572,14 @@ function startWatcher(projectRoot, watchedPaths) {
       const dossier = await readDossier(projectRoot);
       if (!dossier)
         return;
-      const content = await readFile10(filepath, "utf8");
+      const content = await readFile9(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 === join11(projectRoot, card.primaryFile) || filepath.endsWith("/" + card.primaryFile);
+          const absMatch = filepath === join12(projectRoot, card.primaryFile) || filepath.endsWith("/" + card.primaryFile);
           if (absMatch && card.lastScannedHash !== newHash) {
             card.status = "stale";
             const rel = card.primaryFile;
@@ -3501,8 +3589,11 @@ function startWatcher(projectRoot, watchedPaths) {
           }
         }
       }
-      if (mutated)
-        await writeDossier(projectRoot, dossier);
+      if (mutated) {
+        const orchestrator = new ExportOrchestrator(projectRoot);
+        await orchestrator.writeBundle(dossier);
+        console.error(`[vibe-splain] File changed: ${filepath}. Dossier artifacts updated.`);
+      }
     } catch (err) {
       console.error("[vibe-splain] Watcher error:", err);
     }
@@ -3525,7 +3616,7 @@ var scanProjectTool = {
     required: ["projectRoot"]
   }
 };
-async function handleScanProject(args) {
+async function handleScanProject(args, options = {}) {
   const projectRoot = args.projectRoot;
   if (!projectRoot)
     throw new Error("projectRoot is required");
@@ -3537,7 +3628,15 @@ async function handleScanProject(args) {
     version: "2.0.0",
     scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
     projectRoot,
-    map: { ...result.map, brief },
+    map: {
+      ...result.map,
+      brief,
+      validation: result.validation ? {
+        passed: result.validation.passed,
+        errors: result.validation.errors,
+        warnings: result.validation.warnings
+      } : void 0
+    },
     pillars: existing?.pillars ?? [],
     wildDiscoveries: existing?.wildDiscoveries ?? [],
     stalePaths: existing?.stalePaths ?? []
@@ -3547,12 +3646,22 @@ async function handleScanProject(args) {
       dossier.pillars.push({ name: def.name, cardCount: 0, decisions: [] });
     }
   }
-  await writeDossier(projectRoot, dossier);
+  const orchestrator = new ExportOrchestrator(projectRoot);
+  await orchestrator.writeBundle(dossier, {
+    format: options.format,
+    budget: options.budget ? parseInt(options.budget, 10) : void 0,
+    scope: options.scope
+  }, result.store, result.graph);
   startWatcher(projectRoot, result.files.map((f) => f.path));
   console.error(`[vibe-splain] Scan complete. ${result.totalFilesScanned} files, ${result.realSourceCount} real-source, ${result.wildCandidates.length} wild candidates.`);
   const validation = result.validation ?? { passed: true, errors: 0, warnings: 0, reportPath: ".vibe-splainer/validation_report.json" };
+  let statusMsg = "Scan complete.";
+  if (!validation.passed) {
+    statusMsg = `SCAN QUALITY WARNING: ${validation.errors} errors and ${validation.warnings} warnings found in validation report. Delta Engine automation may be blocked.`;
+  }
   return {
     ok: true,
+    message: statusMsg,
     validation: {
       passed: validation.passed,
       errors: validation.errors,
@@ -3636,7 +3745,7 @@ var setProjectBriefTool = {
     required: ["projectRoot", "brief"]
   }
 };
-async function handleSetProjectBrief(args) {
+async function handleSetProjectBrief(args, options = {}) {
   const projectRoot = args.projectRoot;
   const brief = args.brief;
   if (!projectRoot || !brief)
@@ -3646,7 +3755,12 @@ async function handleSetProjectBrief(args) {
     return { error: "No project map found. Run scan_project first." };
   }
   dossier.map.brief = brief;
-  await writeDossier(projectRoot, dossier);
+  const orchestrator = new ExportOrchestrator(projectRoot);
+  await orchestrator.writeBundle(dossier, {
+    format: options.format,
+    budget: options.budget ? parseInt(options.budget, 10) : void 0,
+    scope: options.scope
+  });
   const documented = new Set([...dossier.pillars.flatMap((p) => p.decisions), ...dossier.wildDiscoveries].map((c) => c.primaryFile).filter(Boolean));
   const startHere = dossier.map.topGravity.filter((f) => !documented.has(f));
   const wild = dossier.map.topHeat.filter((f) => !documented.has(f));
@@ -3661,8 +3775,8 @@ async function handleSetProjectBrief(args) {
 }
 
 // dist/mcp/tools/get_file_context.js
-import { readFile as readFile11 } from "fs/promises";
-import { join as join12, relative as relative3, isAbsolute } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { join as join13, relative as relative4, 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.",
@@ -3682,8 +3796,8 @@ 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 : join12(projectRoot, filePath);
-  const relPath = relative3(projectRoot, fullPath);
+  const fullPath = isAbsolute(filePath) ? filePath : join13(projectRoot, filePath);
+  const relPath = relative4(projectRoot, fullPath);
   const evidence = await getFileAnalysis(fullPath);
   if (!evidence) {
     throw new Error(`Could not analyze ${relPath} (unsupported language or parse failure).`);
@@ -3707,7 +3821,7 @@ async function handleGetFileContext(args) {
     smellSpans: evidence.smellSpans
   };
   if (full) {
-    result.source = await readFile11(fullPath, "utf8");
+    result.source = await readFile10(fullPath, "utf8");
   }
   return result;
 }
@@ -3715,8 +3829,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 readFile12 } from "fs/promises";
-import { join as join13 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join14 } from "path";
 var CATEGORIES = ["Bottleneck", "Hack", "Smart-Move", "Risk", "Convention", "Dead-Weight"];
 function normalizeSnippet(s) {
   let out = (s ?? "").replace(/\r\n/g, "\n");
@@ -3761,7 +3875,7 @@ var writeDecisionCardTool = {
     required: ["projectRoot", "pillar", "primaryFile", "title", "thesis", "category", "severity", "narrative", "confidence", "evidence"]
   }
 };
-async function handleWriteDecisionCard(args) {
+async function handleWriteDecisionCard(args, options = {}) {
   const projectRoot = args.projectRoot;
   const pillar = args.pillar;
   const primaryFile = args.primaryFile;
@@ -3804,11 +3918,16 @@ async function handleWriteDecisionCard(args) {
   }
   const store = await readAnalysis(projectRoot);
   const persisted = store?.files[primaryFile];
+  const machineConfidence = persisted?.confidence || "low";
+  const confidenceOrder = { low: 0, medium: 1, high: 2 };
+  if (confidenceOrder[confidence] > confidenceOrder[machineConfidence]) {
+    throw new Error(`Requested confidence "${confidence}" exceeds machine-derived confidence "${machineConfidence}" for this file. Ground your narrative in the MRI evidence.`);
+  }
   const gravity = persisted ? Math.round(persisted.gravity) : void 0;
   const heat = persisted ? Math.round(persisted.heat) : void 0;
   let primaryContent = "";
   try {
-    primaryContent = await readFile12(join13(projectRoot, primaryFile), "utf8");
+    primaryContent = await readFile11(join14(projectRoot, primaryFile), "utf8");
   } catch {
   }
   const hash = createHash3("sha256").update(primaryContent).digest("hex");
@@ -3842,7 +3961,12 @@ async function handleWriteDecisionCard(args) {
   }
   bucket.decisions.push(card);
   bucket.cardCount = bucket.decisions.length;
-  await writeDossier(projectRoot, dossier);
+  const orchestrator = new ExportOrchestrator(projectRoot);
+  await orchestrator.writeBundle(dossier, {
+    format: options.format,
+    budget: options.budget ? parseInt(options.budget, 10) : void 0,
+    scope: options.scope
+  });
   console.error(`[vibe-splain] Card written: "${title}" [${category} sev${severity}] in "${pillar}"${isWild ? " (Wild Discovery)" : ""}`);
   const documented = new Set([...dossier.pillars.flatMap((p) => p.decisions), ...dossier.wildDiscoveries].map((c) => c.primaryFile).filter(Boolean));
   const remaining = [.../* @__PURE__ */ new Set([...dossier.map.topGravity, ...dossier.map.topHeat])].filter((f) => !documented.has(f));
@@ -3992,7 +4116,7 @@ var markStaleTool = {
     required: ["projectRoot", "filePaths"]
   }
 };
-async function handleMarkStale(args) {
+async function handleMarkStale(args, options = {}) {
   const projectRoot = args.projectRoot;
   const filePaths = args.filePaths;
   if (!projectRoot || !filePaths)
@@ -4020,7 +4144,12 @@ async function handleMarkStale(args) {
       dossier.stalePaths.push(filePath);
     }
   }
-  await writeDossier(projectRoot, dossier);
+  const orchestrator = new ExportOrchestrator(projectRoot);
+  await orchestrator.writeBundle(dossier, {
+    format: options.format,
+    budget: options.budget ? parseInt(options.budget, 10) : void 0,
+    scope: options.scope
+  });
   return {
     success: true,
     staleCardsMarked: staleCount,
@@ -4102,10 +4231,10 @@ var TOOL_HANDLERS = {
   get_wild_discoveries: handleGetWildDiscoveries,
   mark_stale: handleMarkStale
 };
-async function startMCPServer() {
+async function startMCPServer(options = {}) {
   await initParser2();
   console.error("[vibe-splain] Tree-Sitter parser initialized");
-  const server = new Server({ name: "vibe-splain", version: "2.0.0" }, { capabilities: { tools: {}, prompts: {} } });
+  const server = new Server({ name: "vibe-splain", version: "3.0.0" }, { capabilities: { tools: {}, prompts: {} } });
   server.setRequestHandler(ListPromptsRequestSchema, async () => ({
     prompts: [
       {
@@ -4202,7 +4331,7 @@ When done, share the exact file:// UI link returned by scan_project. Never inven
       };
     }
     try {
-      const result = await handler(args || {});
+      const result = await handler(args, options);
       return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
       };
@@ -4221,14 +4350,33 @@ When done, share the exact file:// UI link returned by scan_project. Never inven
 }
 
 // dist/commands/serve.js
-async function serveCommand() {
+async function serveCommand(options) {
   console.error("[vibe-splain] Starting MCP server...");
-  await startMCPServer();
+  await startMCPServer(options);
+}
+
+// dist/commands/export.js
+async function exportCommand(projectRoot, options) {
+  const root = projectRoot || process.cwd();
+  console.error(`[vibe-splain] Exporting dossier for ${root}`);
+  const dossier = await readDossier(root);
+  if (!dossier) {
+    console.error("[vibe-splain] Dossier not found. Run scan first.");
+    process.exit(1);
+  }
+  const orchestrator = new ExportOrchestrator(root);
+  await orchestrator.writeBundle(dossier, {
+    format: options.format,
+    budget: options.budget ? parseInt(options.budget, 10) : void 0,
+    scope: options.scope
+  });
+  console.error("[vibe-splain] Export complete.");
 }
 
 // dist/index.js
 var program = new Command();
-program.name("vibe-splain").description("Architectural dossier engine for vibe-coded projects").version("2.5.0");
+program.name("vibe-splain").description("Architectural dossier engine for vibe-coded projects").version("3.0.0");
 program.command("install").description("Patch coding agent MCP config files to register vibe-splain").action(installCommand);
-program.command("serve").description("Start the MCP server (called by the coding agent, not by you)").action(serveCommand);
+program.command("serve").description("Start the MCP server (called by the coding agent, not by you)").option("--format <format>", "Export format (html, markdown, etc.)").option("--budget <budget>", "Token budget for markdown").option("--scope <scope>", "Scope for export").action((options) => serveCommand(options));
+program.command("export [projectRoot]").description("Manually trigger bundle generation").option("--format <format>", "Export format (html, markdown, etc.)").option("--budget <budget>", "Token budget for markdown").option("--scope <scope>", "Scope for export").action(exportCommand);
 program.parse();