vibe-splain 2.4.0 → 2.5.0

package/dist/index.js

@@ -87,12 +87,11 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 
 // ../brain/dist/scanner.js
-import Parser from "web-tree-sitter";
-import { join as join4, dirname, relative, extname, basename, sep } from "path";
-import { fileURLToPath } from "url";
-import { createRequire } from "module";
-import { readFile as readFile4, readdir } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
+import { extname as extname4 } from "path";
+import { readFile as readFile6 } from "fs/promises";
+
+// ../brain/dist/pipeline/orchestrator.js
+import { join as join8 } from "path";
 
 // ../brain/dist/graph.js
 import { join as join2 } from "path";
@@ -125,80 +124,17 @@ async function writeAnalysis(projectRoot, store) {
   const { rename } = await import("fs/promises");
   await rename(tmp, dest);
 }
-var LOAD_BEARING_FAN_IN_THRESHOLD = 10;
-function deriveRiskTypes(f) {
-  const kinds = new Set(f.smells.map((s) => s.kind));
-  const types = [];
-  if (f.gravitySignals.cyclomatic > 15)
-    types.push("state_machine");
-  if (kinds.has("god-file"))
-    types.push("god_object");
-  if (f.gravitySignals.fanIn > 15)
-    types.push("deep_coupling");
-  if (kinds.has("swallowed-catch"))
-    types.push("error_sink");
-  if (f.gravitySignals.fanIn > 10 && f.gravitySignals.publicSurface > 8)
-    types.push("mutation_hotspot");
-  if (kinds.has("todo") && kinds.has("suppression"))
-    types.push("tech_debt");
-  return types.length > 0 ? types : ["complexity_hotspot"];
-}
-function deriveConfidence(f) {
-  if (f.gravitySignals.fanIn >= LOAD_BEARING_FAN_IN_THRESHOLD && f.gravity >= 40)
-    return "high";
-  if (f.gravitySignals.fanIn >= 5 || f.gravity >= 25)
-    return "medium";
-  return "low";
-}
-function findRuntimeEntrypoints(relPath, files, entrypoints) {
-  const found = [];
-  const visited = /* @__PURE__ */ new Set();
-  const queue = [relPath];
-  while (queue.length > 0) {
-    const curr = queue.shift();
-    if (visited.has(curr))
-      continue;
-    visited.add(curr);
-    if (entrypoints.has(curr) && curr !== relPath)
-      found.push(curr);
-    if (found.length >= 5)
-      break;
-    const f = files[curr];
-    if (f) {
-      for (const importer of f.importedBy)
-        if (!visited.has(importer))
-          queue.push(importer);
-    }
-  }
-  return found;
-}
-async function writeDeltaTargets(projectRoot, store, entrypoints = /* @__PURE__ */ new Set()) {
-  const domain = (f) => f.pillarHint && !f.pillarHint.startsWith("community-") ? f.pillarHint : null;
-  const targets = Object.values(store.files).filter((f) => f.isRealSource).sort((a, b) => b.gravity - a.gravity).map((f) => ({
-    path: f.relativePath,
-    gravity: f.gravity,
-    isLoadBearing: f.gravitySignals.fanIn >= LOAD_BEARING_FAN_IN_THRESHOLD,
-    blastRadius: f.importedBy,
-    pillarHint: domain(f),
-    domain: domain(f),
-    riskTypes: deriveRiskTypes(f),
-    severity: f.smells.length > 0 ? Math.max(...f.smells.map((s) => s.severity)) : 0,
-    confidence: deriveConfidence(f),
-    runtimeEntrypoints: findRuntimeEntrypoints(f.relativePath, store.files, entrypoints)
-  }));
-  const dir = join3(projectRoot, ".vibe-splainer");
-  await mkdir2(dir, { recursive: true });
-  const dest = join3(dir, "delta_targets.json");
-  const tmp = dest + ".tmp";
-  await writeFile3(tmp, JSON.stringify(targets, null, 2), "utf8");
-  const { rename } = await import("fs/promises");
-  await rename(tmp, dest);
-}
 
-// ../brain/dist/scanner.js
+// ../brain/dist/pipeline/inventory.js
+import Parser from "web-tree-sitter";
+import { join as join4, 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 { existsSync as existsSync2 } from "fs";
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var require2 = createRequire(import.meta.url);
-var parser = null;
+var _parser = null;
 var langCache = /* @__PURE__ */ new Map();
 var EXT_LANG = {
   ".ts": "typescript",
@@ -230,7 +166,7 @@ function resolveWasm(file) {
       return p;
   } catch {
   }
-  const local = join4(__dirname, "../wasm", file);
+  const local = join4(__dirname, "../../wasm", file);
   return existsSync2(local) ? local : null;
 }
 async function getLanguage(lang) {
@@ -239,7 +175,7 @@ async function getLanguage(lang) {
     return cached;
   const wasm = resolveWasm(LANG_WASM[lang]);
   if (!wasm) {
-    console.error(`[vibe-splain] grammar missing for ${lang} (${LANG_WASM[lang]}); skipping language`);
+    console.error(`[vibe-splain] grammar missing for ${lang} (${LANG_WASM[lang]}); skipping`);
     return null;
   }
   try {
@@ -252,14 +188,14 @@ async function getLanguage(lang) {
   }
 }
 async function initParser() {
-  if (parser)
-    return parser;
+  if (_parser)
+    return _parser;
   await Parser.init();
-  parser = new Parser();
+  _parser = new Parser();
   const ts = await getLanguage("typescript");
   if (ts)
-    parser.setLanguage(ts);
-  return parser;
+    _parser.setLanguage(ts);
+  return _parser;
 }
 async function parseAs(lang, source) {
   const p = await initParser();
@@ -324,6 +260,143 @@ var VENDOR_SEGMENTS = /* @__PURE__ */ new Set([
   "third_party",
   "third-party"
 ]);
+async function collectFiles(dir, projectRoot, acc) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") && entry.name !== ".") {
+      if (entry.isDirectory())
+        continue;
+    }
+    if (EXCLUDE_DIRS.has(entry.name))
+      continue;
+    const fullPath = join4(dir, entry.name);
+    if (entry.isDirectory()) {
+      await collectFiles(fullPath, projectRoot, acc);
+    } else if (entry.isFile()) {
+      const ext = extname(entry.name);
+      if (!SUPPORTED_EXTENSIONS.has(ext))
+        continue;
+      if (EXCLUDE_FILE_PATTERNS.some((p) => p.test(entry.name)))
+        continue;
+      acc.push(fullPath);
+    }
+  }
+}
+function pathDemoteReason(relPath) {
+  const segs = relPath.split(sep);
+  for (const s of segs) {
+    if (VENDOR_SEGMENTS.has(s))
+      return `vendored code (${s})`;
+    if (s.endsWith(".venv") || s === "venv" || s === "env")
+      return "virtual environment";
+  }
+  for (const s of segs) {
+    if (DEMOTE_SEGMENTS.has(s.toLowerCase()))
+      return `non-application path segment (${s})`;
+  }
+  const b = basename(relPath);
+  if (/\.min\./.test(b))
+    return "minified bundle";
+  if (/\.generated\./.test(b))
+    return "generated file";
+  return null;
+}
+function inferFrameworkRole(relPath) {
+  const p = relPath.replace(/\\/g, "/");
+  if (/\.test\.|\.spec\./.test(p))
+    return "test";
+  if (/\.generated\.|__generated__|\.prisma\//.test(p))
+    return "generated";
+  if (/(?:^|\/)app\/.*\/page\.tsx?$/.test(p))
+    return "app_route_page";
+  if (/(?:^|\/)app\/.*\/layout\.tsx?$/.test(p))
+    return "app_route_layout";
+  if (/(?:^|\/)app\/.*\/route\.tsx?$/.test(p))
+    return "app_route_handler";
+  if (/(?:^|\/)app\/.*\/loading\.tsx?$/.test(p))
+    return "app_loading_boundary";
+  if (/(?:^|\/)app\/.*\/error\.tsx?$/.test(p))
+    return "app_error_boundary";
+  if (/(?:^|\/)pages\/api\/trpc\//.test(p))
+    return "trpc_api_route";
+  if (/(?:^|\/)pages\/api\//.test(p))
+    return "pages_api_route";
+  if (/(?:^|\/)pages\//.test(p))
+    return "pages_route";
+  if (/\/hooks\/|\/use[A-Z][^/]*\.(ts|tsx)$/.test(p))
+    return "hook";
+  if (/\/stores?\/|[Ss]tore\.(ts|tsx)$/.test(p))
+    return "store";
+  if (/[Pp]rovider\.(tsx?|jsx?)$|\/providers?\//.test(p))
+    return "provider";
+  if (/\.types\.ts$|\/types\.ts$|\/types\/[^/]+\.ts$/.test(p))
+    return "type_definition";
+  if (/\.(tsx|jsx)$/.test(p))
+    return "component";
+  if (/\.(ts|js|mjs|cjs)$/.test(p))
+    return "utility";
+  return "unknown";
+}
+function inferProductDomain(relPath, importSpecs) {
+  const p = relPath.toLowerCase().replace(/\\/g, "/");
+  if (/\.test\.|\.spec\.|__tests__|\/e2e\/|\/playwright\/|\/cypress\//.test(p)) {
+    return "test_infrastructure";
+  }
+  if (/\.generated\.|__generated__|\.prisma\//.test(p)) {
+    return "generated_noise";
+  }
+  if (p.includes("booking-audit") || p.includes("bookingaudit"))
+    return "booking_audit";
+  if (p.includes("bookeventform") || p.includes("availabletimes") || p.includes("availabletimeslots") || p.includes("usebookings") || p.includes("/pages/api/book/") || p.includes("/api/book/") || p.includes("/booking-successful/") || p.includes("/reschedule/") || p.includes("booking-page-wrapper") || p.includes("/book/") && !p.includes("booking-audit"))
+    return "booking_creation";
+  if (p.includes("modules/bookings") || p.includes("components/booking/actions") || p.includes("/bookings/[status]") || p.includes("/booking/[uid]") || p.includes("/bookings/"))
+    return "booking_management";
+  if (p.includes("event-types") || p.includes("eventtypes") || p.includes("eventavailabilitytab") || p.includes("eventadvancedtab") || p.includes("eventlimits") || p.includes("eventrecurring"))
+    return "event_type_configuration";
+  if (p.includes("availability") || p.includes("/schedules/") || p.includes("/slots/")) {
+    return "availability";
+  }
+  if (p.includes("oauth") || p.includes("nextauth") || p.includes("/auth/oauth") || p.includes("/api/auth/") || importSpecs.some((s) => s.includes("arctic") || s.includes("@auth/core")))
+    return "auth_oauth";
+  if (p.includes("/auth/") || p.includes("signup") || p.includes("login") || p.includes("forgot-password") || p.includes("reset-password") || p.includes("two-factor") || p.includes("verify-email") || importSpecs.some((s) => s.includes("next-auth") || s.includes("@clerk/")))
+    return "auth";
+  if ((p.includes("stripe") || p.includes("paypal") || p.includes("btcpay") || p.includes("alby") || p.includes("payment")) && (p.includes("webhook") || p.includes("hook")))
+    return "payments_webhooks";
+  if (p.includes("stripe") || p.includes("paypal") || p.includes("btcpay") || p.includes("alby") || p.includes("payment") || p.includes("billing") || p.includes("checkout") || p.includes("subscription") || importSpecs.some((s) => s.includes("stripe") || s.includes("@stripe/")))
+    return "payments";
+  if (p.includes("webhook"))
+    return "webhooks";
+  if (p.includes("app-store") || p.includes("appstore") || p.includes("/apps/") || p.includes("modules/apps"))
+    return "apps_marketplace";
+  if (p.includes("calendar") || p.includes("selected-calendars") || importSpecs.some((s) => s.includes("googleapis") || s.includes("@google-cloud/")))
+    return "calendar_integrations";
+  if (p.includes("video") || p.includes("calvideo") || p.includes("daily.co"))
+    return "video";
+  if (p.includes("onboarding") || p.includes("getting-started"))
+    return "onboarding";
+  if (p.includes("/settings/") || p.includes("/settings."))
+    return "settings";
+  if (p.includes("/admin/") || p.includes("/admin."))
+    return "admin";
+  if (p.includes("data-table") || p.includes("datatable") || p.includes("datasegment") || p.includes("segment"))
+    return "data_table";
+  if (p.includes("shell/navigation") || p.includes("navigationitem") || p.includes("/shell/") || p.includes("sidebar") || p.includes("topnav") || p.includes("mainnav"))
+    return "shell_navigation";
+  if (p.includes("form-builder") || p.includes("formbuilder") || p.includes("/forms/") || p.includes("routingforms"))
+    return "forms";
+  if (p.includes("embed"))
+    return "embed";
+  if (p.includes("notification") || p.includes("/email/") || p.includes("/emails/") || importSpecs.some((s) => s.includes("nodemailer") || s.includes("resend") || s.includes("@sendgrid/")))
+    return "notifications";
+  if (p.includes("middleware") && !p.includes("pages/api/") || p.includes("/router.") || p.includes("routerconfig"))
+    return "routing_infrastructure";
+  return "unknown";
+}
 var PILLAR_KEYWORDS = {
   "Auth": [
     "passport",
@@ -376,20 +449,6 @@ var PILLAR_KEYWORDS = {
     "paddle",
     "lemon-squeezy"
   ],
-  "Routing": [
-    "express",
-    "fastify",
-    "koa",
-    "koa-router",
-    "next/router",
-    "next/navigation",
-    "react-router",
-    "@remix-run/",
-    "hono",
-    "express-rate-limit",
-    "cors",
-    "helmet"
-  ],
   "Queue": [
     "bull",
     "bullmq",
@@ -412,35 +471,14 @@ var PILLAR_KEYWORDS = {
     "sharp",
     "imagekit"
   ],
-  "Config": [
-    "dotenv",
-    "convict",
-    "env-var",
-    "@t3-oss/env",
-    "envalid"
-  ],
-  "Email": [
-    "nodemailer",
-    "resend",
-    "@sendgrid/",
-    "postmark",
-    "@resend/",
-    "mailgun"
-  ],
-  "Realtime": [
-    "socket.io",
-    "ws",
-    "pusher",
-    "ably",
-    "@supabase/realtime",
-    "socket.io-client"
-  ]
+  "Config": ["dotenv", "convict", "env-var", "@t3-oss/env", "envalid"],
+  "Email": ["nodemailer", "resend", "@sendgrid/", "postmark", "@resend/", "mailgun"],
+  "Realtime": ["socket.io", "ws", "pusher", "ably", "@supabase/realtime", "socket.io-client"]
 };
 var PILLAR_PATH_PATTERNS = {
   "Auth": /(?:^|[\/\\])(?:auth|login|signup|register|session|oauth)(?:[\/\\]|$)/i,
   "Database": /(?:^|[\/\\])(?:db|database|models?|schema|migrations?|seeds?)(?:[\/\\]|$)/i,
   "Payments": /(?:^|[\/\\])(?:pay|payments?|billing|checkout|subscriptions?|stripe)(?:[\/\\]|$)/i,
-  "Routing": /(?:^|[\/\\])(?:routes?|router|middleware|api)(?:[\/\\]|$)/i,
   "Queue": /(?:^|[\/\\])(?:queues?|workers?|jobs?|consumers?|producers?)(?:[\/\\]|$)/i,
   "Storage": /(?:^|[\/\\])(?:storage|uploads?|s3|blobs?|media)(?:[\/\\]|$)/i,
   "Config": /(?:^|[\/\\])(?:config|env|settings?)(?:[\/\\]|$)/i,
@@ -481,52 +519,6 @@ function matchPillarByPath(relPath) {
   }
   return null;
 }
-async function collectFiles(dir, projectRoot, acc) {
-  let entries;
-  try {
-    entries = await readdir(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (entry.name.startsWith(".") && entry.name !== ".") {
-      if (entry.isDirectory())
-        continue;
-    }
-    if (EXCLUDE_DIRS.has(entry.name))
-      continue;
-    const fullPath = join4(dir, entry.name);
-    if (entry.isDirectory()) {
-      await collectFiles(fullPath, projectRoot, acc);
-    } else if (entry.isFile()) {
-      const ext = extname(entry.name);
-      if (!SUPPORTED_EXTENSIONS.has(ext))
-        continue;
-      if (EXCLUDE_FILE_PATTERNS.some((p) => p.test(entry.name)))
-        continue;
-      acc.push(fullPath);
-    }
-  }
-}
-function pathDemoteReason(relPath) {
-  const segs = relPath.split(sep);
-  for (const s of segs) {
-    if (VENDOR_SEGMENTS.has(s))
-      return `vendored code (${s})`;
-    if (s.endsWith(".venv") || s === "venv" || s === "env")
-      return "virtual environment";
-  }
-  for (const s of segs) {
-    if (DEMOTE_SEGMENTS.has(s.toLowerCase()))
-      return `non-application path segment (${s})`;
-  }
-  const base = basename(relPath);
-  if (/\.min\./.test(base))
-    return "minified bundle";
-  if (/\.generated\./.test(base))
-    return "generated file";
-  return null;
-}
 function extractImports(source, lang) {
   const specs = [];
   if (lang === "python") {
@@ -575,77 +567,92 @@ function extractImports(source, lang) {
   }
   const re = /(?:import|export)\s[^;]*?from\s*['"]([^'"]+)['"]|(?:import|require)\s*\(\s*['"]([^'"]+)['"]/g;
   let m;
-  while ((m = re.exec(source)) !== null) {
+  while ((m = re.exec(source)) !== null)
     specs.push(m[1] || m[2]);
-  }
   return specs;
 }
-var JS_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-function resolveImport(spec, fromAbs, lang, projectRoot, fileSet, basenameIndex) {
-  if (lang === "python") {
-    return resolvePython(spec, fromAbs, projectRoot, fileSet);
-  }
-  if (lang === "typescript" || lang === "tsx" || lang === "javascript") {
-    if (!spec.startsWith("."))
-      return null;
-    const base = join4(dirname(fromAbs), spec);
-    return tryJsCandidates(base, projectRoot, fileSet);
-  }
-  return resolveGeneric(spec, projectRoot, fileSet, basenameIndex);
-}
-function tryJsCandidates(base, projectRoot, fileSet) {
-  const candidates = [];
-  for (const ext of JS_EXTS)
-    candidates.push(base + ext);
-  for (const ext of JS_EXTS)
-    candidates.push(join4(base, "index" + ext));
-  candidates.unshift(base);
-  for (const c of candidates) {
-    const rel = relative(projectRoot, c);
-    if (fileSet.has(rel))
-      return rel;
-  }
-  return null;
-}
-function resolvePython(spec, fromAbs, projectRoot, fileSet) {
-  let modulePath;
-  if (spec.startsWith(".")) {
-    const dots = spec.match(/^\.+/)[0].length;
-    let dir = dirname(fromAbs);
-    for (let i = 1; i < dots; i++)
-      dir = dirname(dir);
-    const rest = spec.slice(dots).replace(/\./g, sep);
-    modulePath = rest ? join4(dir, rest) : dir;
-  } else {
-    modulePath = join4(projectRoot, spec.replace(/\./g, sep));
+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");
+  if (existsSync2(pkgPath)) {
+    try {
+      const pkg = JSON.parse(await readFile4(pkgPath, "utf8"));
+      stack.add("Node.js");
+      const deps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
+      for (const known of ["react", "next", "vue", "svelte", "express", "fastify", "typescript", "vite"]) {
+        if (deps[known])
+          stack.add(known === "next" ? "Next.js" : known[0].toUpperCase() + known.slice(1));
+      }
+      const addEntry = (p) => {
+        if (!p)
+          return;
+        const abs = join4(projectRoot, p);
+        const r = relative(projectRoot, abs);
+        if (files.includes(abs))
+          entrypoints.add(r);
+      };
+      addEntry(pkg.main);
+      if (typeof pkg.bin === "string")
+        addEntry(pkg.bin);
+      else if (pkg.bin)
+        for (const v of Object.values(pkg.bin))
+          addEntry(v);
+    } catch {
+    }
   }
-  const candidates = [modulePath + ".py", join4(modulePath, "__init__.py")];
-  for (const c of candidates) {
-    const rel = relative(projectRoot, c);
-    if (fileSet.has(rel))
-      return rel;
+  const pyproject = join4(projectRoot, "pyproject.toml");
+  const setupPy = join4(projectRoot, "setup.py");
+  const requirements = join4(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");
+        } catch {
+        }
+      }
+    }
+    for (const known of ["pygame", "PySide6", "PyQt5", "PyQt6", "flask", "django", "fastapi", "numpy", "pandas", "torch", "tensorflow"]) {
+      if (new RegExp(known, "i").test(reqText))
+        stack.add(known);
+    }
   }
-  if (!spec.startsWith(".")) {
-    const last = spec.split(".").pop();
-    void last;
+  if (existsSync2(join4(projectRoot, "go.mod")))
+    stack.add("Go");
+  if (existsSync2(join4(projectRoot, "Cargo.toml")))
+    stack.add("Rust");
+  if (existsSync2(join4(projectRoot, "pom.xml")) || existsSync2(join4(projectRoot, "build.gradle")))
+    stack.add("Java");
+  for (const abs of files) {
+    const r = rel(abs);
+    const b = basename(r);
+    if (b === "main.py" || b === "__main__.py")
+      entrypoints.add(r);
+    if (/^index\.(ts|tsx|js|jsx|mjs|cjs)$/.test(b) && dirname(r).split(sep).length <= 2)
+      entrypoints.add(r);
+    if (b === "main.go" && r.includes("cmd" + sep))
+      entrypoints.add(r);
+    if (b === "main.go" && !r.includes(sep))
+      entrypoints.add(r);
+    if (b === "main.rs" || b === "lib.rs")
+      entrypoints.add(r);
   }
-  return null;
-}
-function resolveGeneric(spec, projectRoot, fileSet, basenameIndex) {
-  const normalized = spec.replace(/^crate::/, "").replace(/::/g, "/").replace(/\./g, "/");
-  const parts = normalized.split("/").filter(Boolean);
-  if (parts.length === 0)
-    return null;
-  const last = parts[parts.length - 1];
-  for (const rel of fileSet) {
-    const noExt = rel.slice(0, rel.length - extname(rel).length);
-    if (noExt.endsWith(parts.join(sep)))
-      return rel;
+  if (stack.has("Next.js")) {
+    const appRouterNames = /* @__PURE__ */ new Set(["page", "layout", "route", "loading", "error", "not-found", "template", "default"]);
+    for (const abs of files) {
+      const r = rel(abs);
+      const stem = basename(r, extname(r));
+      if (/(?:^|[/\\])app[/\\]/.test(r) && appRouterNames.has(stem))
+        entrypoints.add(r);
+      if (/(?:^|[/\\])pages[/\\]/.test(r) && !stem.startsWith("_"))
+        entrypoints.add(r);
+    }
   }
-  const byBase = basenameIndex.get(last);
-  if (byBase && byBase.length === 1)
-    return byBase[0];
-  return null;
+  return { stack: [...stack], entrypoints };
 }
 var FUNCTION_TYPES = /* @__PURE__ */ new Set([
   "function_declaration",
@@ -806,41 +813,120 @@ function collectFunctionNodes(root) {
   walk(root);
   return out;
 }
-function catchIsSwallowed(node, lang) {
+function catchIsSwallowed(node) {
   const bodyText = node.text;
   const inner = bodyText.replace(/^[^{:]*[{:]/, "");
   const meaningful = inner.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("//") && !l.startsWith("#") && l !== "}" && l !== "pass");
   if (meaningful.length === 0)
     return true;
-  const onlyLogs = meaningful.every((l) => /^(console\.(log|error|warn|info)|print|println!?|System\.out|logger?\.)/.test(l) || l === "pass" || l === "{" || l === "});" || l === ")" || l === "`");
-  return onlyLogs;
+  return meaningful.every((l) => /^(console\.(log|error|warn|info)|print|println!?|System\.out|logger?\.)/.test(l) || l === "pass" || l === "{" || l === "});" || l === ")" || l === "`");
 }
-function analyzeAst(source, lang, tree) {
-  const root = tree.rootNode;
-  const lines = source.split("\n");
-  const loc = lines.length;
-  const cyclomatic = countDecisions(root);
-  const maxNesting = computeNesting(root, 0);
-  const smells = [];
-  let todos = 0, suppressions = 0;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (TODO_RE.test(line)) {
-      todos++;
-      smells.push({ kind: "todo", line: i + 1, endLine: i + 1, text: line.trim().slice(0, 200), severity: 2, note: "unfinished / known-bad marker" });
-    }
-    if (SUPPRESS_RE.test(line)) {
-      suppressions++;
-      smells.push({ kind: "suppression", line: i + 1, endLine: i + 1, text: line.trim().slice(0, 200), severity: 3, note: "type/lint safety suppressed" });
-    }
-  }
-  let magicNumbers = 0;
-  const magicWalk = (n) => {
-    if (n.type === "number" || n.type === "integer_literal" || n.type === "float_literal" || n.type === "int_literal") {
-      const v = n.text.replace(/_/g, "");
-      if (!["0", "1", "2", "-1", "100", "1000"].includes(v) && /^\d{2,}$/.test(v)) {
-        magicNumbers++;
+function collectExports(root, lang) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (name, node) => {
+    if (!name || seen.has(name))
+      return;
+    seen.add(name);
+    out.push({ name, text: firstLine(node.text).trim().slice(0, 200) });
+  };
+  if (lang === "python") {
+    for (const c of root.children) {
+      if (c.type === "function_definition" || c.type === "class_definition") {
+        const name = c.childForFieldName("name")?.text;
+        if (name && !name.startsWith("_"))
+          push(name, c);
+      }
+    }
+    return out;
+  }
+  if (lang === "go") {
+    const walk2 = (n) => {
+      if (n.type === "function_declaration" || n.type === "method_declaration" || n.type === "type_declaration") {
+        const name = n.childForFieldName("name")?.text;
+        if (name && /^[A-Z]/.test(name))
+          push(name, n);
+      }
+      for (const c of n.children)
+        walk2(c);
+    };
+    walk2(root);
+    return out;
+  }
+  if (lang === "rust") {
+    const walk2 = (n) => {
+      if (/_item$/.test(n.type) && n.children.some((c) => c.type === "visibility_modifier")) {
+        const name = n.childForFieldName("name")?.text;
+        push(name, n);
+      }
+      for (const c of n.children)
+        walk2(c);
+    };
+    walk2(root);
+    return out;
+  }
+  if (lang === "java") {
+    const walk2 = (n) => {
+      if ((n.type === "method_declaration" || n.type === "class_declaration") && /\bpublic\b/.test(firstLine(n.text))) {
+        const name = n.childForFieldName("name")?.text;
+        push(name, n);
+      }
+      for (const c of n.children)
+        walk2(c);
+    };
+    walk2(root);
+    return out;
+  }
+  const walk = (n) => {
+    if (n.type === "export_statement") {
+      const decl = n.childForFieldName("declaration");
+      if (decl) {
+        const name = decl.childForFieldName("name")?.text;
+        if (name)
+          push(name, decl);
+        for (const c of decl.namedChildren) {
+          const dn = c.childForFieldName("name")?.text;
+          if (dn)
+            push(dn, c);
+        }
+      }
+      for (const spec of n.descendantsOfType("export_specifier")) {
+        push(spec.childForFieldName("name")?.text, spec);
       }
+      if (n.text.includes("export default"))
+        push("default", n);
+    }
+    for (const c of n.children)
+      walk(c);
+  };
+  walk(root);
+  return out;
+}
+function analyzeAst(source, lang, tree) {
+  const root = tree.rootNode;
+  const lines = source.split("\n");
+  const loc = lines.length;
+  const cyclomatic = countDecisions(root);
+  const maxNesting = computeNesting(root, 0);
+  const smells = [];
+  let todos = 0, suppressions = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (TODO_RE.test(line)) {
+      todos++;
+      smells.push({ kind: "todo", line: i + 1, endLine: i + 1, text: line.trim().slice(0, 200), severity: 2, note: "unfinished / known-bad marker" });
+    }
+    if (SUPPRESS_RE.test(line)) {
+      suppressions++;
+      smells.push({ kind: "suppression", line: i + 1, endLine: i + 1, text: line.trim().slice(0, 200), severity: 3, note: "type/lint safety suppressed" });
+    }
+  }
+  let magicNumbers = 0;
+  const magicWalk = (n) => {
+    if (n.type === "number" || n.type === "integer_literal" || n.type === "float_literal" || n.type === "int_literal") {
+      const v = n.text.replace(/_/g, "");
+      if (!["0", "1", "2", "-1", "100", "1000"].includes(v) && /^\d{2,}$/.test(v))
+        magicNumbers++;
     }
     for (const c of n.children)
       magicWalk(c);
@@ -851,7 +937,7 @@ function analyzeAst(source, lang, tree) {
   }
   let swallowedCatches = 0;
   const catchWalk = (n) => {
-    if (CATCH_TYPES.has(n.type) && catchIsSwallowed(n, lang)) {
+    if (CATCH_TYPES.has(n.type) && catchIsSwallowed(n)) {
       swallowedCatches++;
       smells.push({
         kind: "swallowed-catch",
@@ -927,86 +1013,596 @@ function analyzeAst(source, lang, tree) {
     hotSpans
   };
 }
-function collectExports(root, lang) {
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  const push = (name, node) => {
-    if (!name || seen.has(name))
-      return;
-    seen.add(name);
-    out.push({ name, text: firstLine(node.text).trim().slice(0, 200) });
+var SMELL_WEIGHT = {
+  "todo": 3,
+  "suppression": 5,
+  "swallowed-catch": 10,
+  "deep-nesting": 6,
+  "long-function": 5,
+  "magic-number": 3,
+  "god-file": 14
+};
+function computeHeat(smells) {
+  let sum = 0;
+  for (const s of smells)
+    sum += s.severity * SMELL_WEIGHT[s.kind];
+  return Math.min(100, sum);
+}
+async function runInventory(projectRoot) {
+  await initParser();
+  const abs = [];
+  await collectFiles(projectRoot, projectRoot, abs);
+  const fileSet = new Set(abs.map((f) => relative(projectRoot, f)));
+  const basenameIndex = /* @__PURE__ */ new Map();
+  for (const rel of fileSet) {
+    const b = basename(rel).slice(0, basename(rel).length - extname(rel).length);
+    if (!basenameIndex.has(b))
+      basenameIndex.set(b, []);
+    basenameIndex.get(b).push(rel);
+  }
+  const { stack, entrypoints } = await detectStackAndEntrypoints(projectRoot, abs);
+  const work = [];
+  for (const file of abs) {
+    const rel = relative(projectRoot, file);
+    const ext = extname(file);
+    const lang = EXT_LANG[ext];
+    if (!lang)
+      continue;
+    let source;
+    try {
+      source = await readFile4(file, "utf8");
+    } catch {
+      continue;
+    }
+    if (/if\s+__name__\s*==\s*['"]__main__['"]/.test(source) || /^#![^\n]*\b(node|python\d?)\b/.test(source)) {
+      entrypoints.add(rel);
+    }
+    const tree = await parseAs(lang, source);
+    if (!tree)
+      continue;
+    const ast = analyzeAst(source, lang, tree);
+    const importSpecs = extractImports(source, lang);
+    const frameworkRole = inferFrameworkRole(rel);
+    const productDomain = inferProductDomain(rel, importSpecs);
+    work.push({
+      abs: file,
+      rel,
+      lang,
+      source,
+      ast,
+      importSpecs,
+      pathDemote: pathDemoteReason(rel),
+      frameworkRole,
+      productDomain
+    });
+  }
+  const dir = join4(projectRoot, ".vibe-splainer");
+  await mkdir3(dir, { recursive: true });
+  const stage01 = {
+    files: work.map((w) => ({
+      absPath: w.abs,
+      relPath: w.rel,
+      language: w.lang,
+      demoteReason: w.pathDemote
+    })),
+    totalCount: work.length,
+    realSourceCount: work.filter((w) => !w.pathDemote).length
   };
-  if (lang === "python") {
-    for (const c of root.children) {
-      if (c.type === "function_definition" || c.type === "class_definition") {
-        const name = c.childForFieldName("name")?.text;
-        if (name && !name.startsWith("_"))
-          push(name, c);
+  await writeFile4(join4(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");
+  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");
+  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 { existsSync as existsSync3 } from "fs";
+function parseJsonLenient(text) {
+  const stripped = text.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  try {
+    return JSON.parse(stripped);
+  } catch {
+    return null;
+  }
+}
+async function extractTsConfigPaths(tsconfigPath, projectRoot, depth = 0) {
+  if (depth > 3 || !existsSync3(tsconfigPath))
+    return {};
+  let raw;
+  try {
+    raw = await readFile5(tsconfigPath, "utf8");
+  } catch {
+    return {};
+  }
+  const parsed = parseJsonLenient(raw);
+  if (!parsed)
+    return {};
+  const result = {};
+  if (typeof parsed.extends === "string") {
+    const baseFile = join5(dirname2(tsconfigPath), parsed.extends);
+    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 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 key = alias.replace(/\/\*$/, "");
+    result[key] = resolved;
+  }
+  return result;
+}
+async function discoverWorkspacePackages(projectRoot) {
+  const packages = {};
+  const pkgPath = join5(projectRoot, "package.json");
+  if (!existsSync3(pkgPath))
+    return packages;
+  let rootPkg;
+  try {
+    rootPkg = JSON.parse(await readFile5(pkgPath, "utf8"));
+  } catch {
+    return packages;
+  }
+  const workspaces = rootPkg.workspaces;
+  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);
+    if (!existsSync3(absPrefix))
+      continue;
+    const { readdir: readdir2 } = await import("fs/promises");
+    let entries = [];
+    try {
+      const dirents = await readdir2(absPrefix, { withFileTypes: true });
+      entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const wsPkgPath = join5(absPrefix, entry, "package.json");
+      if (!existsSync3(wsPkgPath))
+        continue;
+      try {
+        const wsPkg = JSON.parse(await readFile5(wsPkgPath, "utf8"));
+        if (typeof wsPkg.name === "string") {
+          packages[wsPkg.name] = relative2(projectRoot, join5(absPrefix, entry));
+        }
+      } catch {
+        continue;
       }
     }
-    return out;
   }
-  if (lang === "go") {
-    const walk2 = (n) => {
-      if (n.type === "function_declaration" || n.type === "method_declaration" || n.type === "type_declaration") {
-        const name = n.childForFieldName("name")?.text;
-        if (name && /^[A-Z]/.test(name))
-          push(name, n);
+  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);
       }
-      for (const c of n.children)
-        walk2(c);
-    };
-    walk2(root);
-    return out;
+    } catch {
+      continue;
+    }
   }
-  if (lang === "rust") {
-    const walk2 = (n) => {
-      if (/_item$/.test(n.type) && n.children.some((c) => c.type === "visibility_modifier")) {
-        const name = n.childForFieldName("name")?.text;
-        push(name, n);
-      }
-      for (const c of n.children)
-        walk2(c);
-    };
-    walk2(root);
-    return out;
+  return result;
+}
+var CONVENTIONAL_ALIASES = [
+  { prefix: "~/", replacement: "" },
+  { prefix: "@components/", replacement: "components/" },
+  { prefix: "@lib/", replacement: "lib/" },
+  { prefix: "@server/", replacement: "server/" },
+  { prefix: "@calcom/web/", replacement: "" },
+  { prefix: "@calcom/features/", replacement: "../packages/features/" },
+  { prefix: "@calcom/lib/", replacement: "../packages/lib/" },
+  { prefix: "@calcom/prisma/", replacement: "../packages/prisma/" },
+  { prefix: "@calcom/trpc/", replacement: "../packages/trpc/" },
+  { prefix: "@calcom/ui/", replacement: "../packages/ui/" },
+  { prefix: "@calcom/emails/", replacement: "../packages/emails/" }
+];
+async function buildAliasMap(projectRoot) {
+  const rootPaths = await extractTsConfigPaths(join5(projectRoot, "tsconfig.json"), projectRoot);
+  const workspacePackages = await discoverWorkspacePackages(projectRoot);
+  const appPaths = await discoverAppTsConfigPaths(projectRoot);
+  const resolvedAliases = { ...appPaths, ...rootPaths };
+  for (const [pkgName, pkgDir] of Object.entries(workspacePackages)) {
+    if (!(pkgName in resolvedAliases)) {
+      resolvedAliases[pkgName] = pkgDir;
+    }
   }
-  if (lang === "java") {
-    const walk2 = (n) => {
-      if ((n.type === "method_declaration" || n.type === "class_declaration") && /\bpublic\b/.test(firstLine(n.text))) {
-        const name = n.childForFieldName("name")?.text;
-        push(name, n);
+  return { resolvedAliases, workspacePackages };
+}
+var JS_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+function tryJsCandidates(base, projectRoot, fileSet) {
+  const candidates = [];
+  candidates.unshift(base);
+  for (const ext of JS_EXTS)
+    candidates.push(base + ext);
+  for (const ext of JS_EXTS)
+    candidates.push(join5(base, "index" + ext));
+  for (const c of candidates) {
+    const rel = relative2(projectRoot, c);
+    if (fileSet.has(rel))
+      return rel;
+  }
+  return null;
+}
+function resolvePython(spec, fromAbs, projectRoot, fileSet) {
+  let modulePath;
+  if (spec.startsWith(".")) {
+    const dots = spec.match(/^\.+/)[0].length;
+    let dir = dirname2(fromAbs);
+    for (let i = 1; i < dots; i++)
+      dir = dirname2(dir);
+    const rest = spec.slice(dots).replace(/\./g, sep2);
+    modulePath = rest ? join5(dir, rest) : dir;
+  } else {
+    modulePath = join5(projectRoot, spec.replace(/\./g, sep2));
+  }
+  for (const c of [modulePath + ".py", join5(modulePath, "__init__.py")]) {
+    if (fileSet.has(relative2(projectRoot, c)))
+      return relative2(projectRoot, c);
+  }
+  return null;
+}
+function resolveGeneric(spec, projectRoot, fileSet, basenameIndex) {
+  const normalized = spec.replace(/^crate::/, "").replace(/::/g, "/").replace(/\./g, "/");
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length === 0)
+    return null;
+  const last = parts[parts.length - 1];
+  for (const rel of fileSet) {
+    const noExt = rel.slice(0, rel.length - extname2(rel).length);
+    if (noExt.endsWith(parts.join(sep2)))
+      return rel;
+  }
+  const byBase = basenameIndex.get(last);
+  if (byBase && byBase.length === 1)
+    return byBase[0];
+  return null;
+}
+function resolveImportWithAliasMap(spec, fromAbs, lang, projectRoot, fileSet, basenameIndex, aliasMap) {
+  if (lang === "python") {
+    return { resolved: resolvePython(spec, fromAbs, projectRoot, fileSet), isAlias: false };
+  }
+  if (lang === "typescript" || lang === "tsx" || lang === "javascript") {
+    if (spec.startsWith(".")) {
+      const base = join5(dirname2(fromAbs), spec);
+      return { resolved: tryJsCandidates(base, projectRoot, fileSet), isAlias: false };
+    }
+    for (const [prefix, replacement] of Object.entries(aliasMap.resolvedAliases)) {
+      if (spec === prefix || spec.startsWith(prefix + "/")) {
+        const rest = spec.slice(prefix.length).replace(/^\//, "");
+        const base = join5(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` };
       }
-      for (const c of n.children)
-        walk2(c);
-    };
-    walk2(root);
-    return out;
+    }
+    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 resolved = tryJsCandidates(base, projectRoot, fileSet);
+        return { resolved, isAlias: true, reason: resolved ? void 0 : `workspace package '${pkgName}' found but subpath '${rest}' not in file set` };
+      }
+    }
+    for (const { prefix, replacement } of CONVENTIONAL_ALIASES) {
+      if (spec.startsWith(prefix)) {
+        const rest = replacement + spec.slice(prefix.length);
+        const base = join5(projectRoot, rest);
+        const resolved = tryJsCandidates(base, projectRoot, fileSet);
+        return { resolved, isAlias: true, reason: resolved ? void 0 : `conventional alias '${prefix}' \u2192 path not found` };
+      }
+    }
+    return { resolved: null, isAlias: false };
   }
-  const walk = (n) => {
-    if (n.type === "export_statement") {
-      const decl = n.childForFieldName("declaration");
-      if (decl) {
-        const name = decl.childForFieldName("name")?.text;
-        if (name)
-          push(name, decl);
-        for (const c of decl.namedChildren) {
-          const dn = c.childForFieldName("name")?.text;
-          if (dn)
-            push(dn, c);
+  return { resolved: resolveGeneric(spec, projectRoot, fileSet, basenameIndex), isAlias: false };
+}
+async function runResolution(projectRoot, inv) {
+  const aliasMap = await buildAliasMap(projectRoot);
+  const { work, fileSet, basenameIndex } = inv;
+  const importedBy = /* @__PURE__ */ new Map();
+  const importsResolved = /* @__PURE__ */ new Map();
+  const importsUnresolved = /* @__PURE__ */ new Map();
+  const fanOut = /* @__PURE__ */ new Map();
+  for (const w of work) {
+    importedBy.set(w.rel, /* @__PURE__ */ new Set());
+    importsResolved.set(w.rel, /* @__PURE__ */ new Set());
+    importsUnresolved.set(w.rel, /* @__PURE__ */ new Set());
+  }
+  const graph = { nodes: {}, edges: [] };
+  for (const w of work) {
+    graph.nodes[w.rel] = { imports: w.importSpecs };
+  }
+  const resolutionFailuresByFile = {};
+  const resolutionFailureReasons = {};
+  const unresolvedSet = /* @__PURE__ */ new Set();
+  for (const w of work) {
+    const distinctModules = /* @__PURE__ */ new Set();
+    for (const spec of w.importSpecs) {
+      distinctModules.add(spec);
+      const { resolved, isAlias, reason } = resolveImportWithAliasMap(spec, w.abs, w.lang, projectRoot, fileSet, basenameIndex, aliasMap);
+      if (resolved && resolved !== w.rel && importedBy.has(resolved)) {
+        importedBy.get(resolved).add(w.rel);
+        importsResolved.get(w.rel).add(resolved);
+        graph.edges.push({ from: w.rel, to: resolved });
+      } else if (resolved === null && isAlias) {
+        importsUnresolved.get(w.rel).add(spec);
+        unresolvedSet.add(spec);
+        if (reason) {
+          if (!resolutionFailuresByFile[w.rel])
+            resolutionFailuresByFile[w.rel] = [];
+          resolutionFailuresByFile[w.rel].push(spec);
+          if (!resolutionFailureReasons[spec])
+            resolutionFailureReasons[spec] = reason;
         }
       }
-      for (const spec of n.descendantsOfType("export_specifier")) {
-        push(spec.childForFieldName("name")?.text, spec);
-      }
-      if (n.text.includes("export default"))
-        push("default", n);
     }
-    for (const c of n.children)
-      walk(c);
+    fanOut.set(w.rel, distinctModules.size);
+  }
+  const unresolvedImports = [...unresolvedSet];
+  const dir = join5(projectRoot, ".vibe-splainer");
+  await mkdir4(dir, { recursive: true });
+  const stage04 = {
+    resolvedAliases: aliasMap.resolvedAliases,
+    workspacePackages: aliasMap.workspacePackages,
+    unresolvedImports,
+    resolutionFailuresByFile,
+    resolutionFailureReasons
   };
-  walk(root);
-  return out;
+  await writeFile5(join5(dir, "stage-04-aliases.json"), JSON.stringify(stage04, null, 2), "utf8");
+  return {
+    aliasMap,
+    importedBy,
+    importsResolved,
+    importsUnresolved,
+    fanOut,
+    graph,
+    unresolvedImports,
+    resolutionFailuresByFile,
+    resolutionFailureReasons
+  };
+}
+
+// ../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";
+function inferSideEffectProfile(source, importSpecs, productDomain, frameworkRole) {
+  const effects = /* @__PURE__ */ new Set();
+  if (/router\.(push|replace|back)\(|redirect\(|notFound\(|permanentRedirect\(/.test(source)) {
+    effects.add("redirect");
+  }
+  if (/["']use server["']/.test(source))
+    effects.add("server_action");
+  if (/useMutation\b|\.mutate\b|\.mutateAsync\b/.test(source))
+    effects.add("trpc_mutation");
+  if (/sdkActionManager\.fire|telemetry\.|posthog\.|mixpanel\.|amplitude\.|ga\(/.test(source) || importSpecs.some((s) => /analytics|telemetry|posthog|mixpanel|amplitude/.test(s)))
+    effects.add("analytics_event");
+  if (/prisma\s*[.?]\s*\w+\s*[.?]\s*(create|update|upsert|delete|deleteMany|updateMany|createMany|transaction|executeRaw|queryRaw)\b/.test(source)) {
+    effects.add("database_write");
+  }
+  if (/prisma\s*[.?]\s*\w+\s*[.?]\s*(findMany|findUnique|findFirst|findFirstOrThrow|findUniqueOrThrow|count|aggregate|groupBy)\b/.test(source)) {
+    effects.add("database_read");
+  }
+  if (/createBooking|handleNewBooking|cancelBooking|rescheduleBooking|handleBooking|createRecurring/.test(source) || productDomain === "booking_creation" && /useMutation\b|\.mutate\b|\.mutateAsync\b/.test(source))
+    effects.add("booking_mutation");
+  if (/stripe\.webhooks\.(constructEvent|constructEventAsync)|webhookSecret|validateWebhook|verifyWebhook|verifySignature/.test(source) || productDomain === "payments_webhooks" && frameworkRole === "pages_api_route")
+    effects.add("webhook_ingress");
+  if (importSpecs.some((s) => /stripe|paypal|btcpay|alby/.test(s.toLowerCase())) || /stripe\.|paymentIntent|createPaymentIntent|confirmPayment|createCharge/.test(source) || productDomain === "payments_webhooks" && effects.has("webhook_ingress"))
+    effects.add("payment_mutation");
+  if (/signIn\b|signOut\b|createSession|destroySession|issueToken|refreshToken|getToken/.test(source)) {
+    effects.add("auth_token_mutation");
+  }
+  if (/triggerWebhook|sendWebhook|webhook\.send\b/.test(source))
+    effects.add("webhook_delivery");
+  if (/sendEmail|sendMail\b|mailer\./.test(source) || importSpecs.some((s) => /nodemailer|resend|sendgrid|postmark|mailgun/.test(s)))
+    effects.add("email_send");
+  if (/createCalendarEvent|updateCalendarEvent|deleteCalendarEvent|calendar\.events\.(insert|update|delete|patch)/.test(source)) {
+    effects.add("calendar_mutation");
+  }
+  if (/revalidatePath\b|revalidateTag\b/.test(source))
+    effects.add("cache_revalidation");
+  if (/localStorage\.|sessionStorage\./.test(source))
+    effects.add("local_storage");
+  if (/indexedDB\b|new Dexie|idb\./.test(source))
+    effects.add("indexed_db");
+  if (/\bfetch\s*\(|axios\.(get|post|put|patch|delete)\b/.test(source)) {
+    effects.add("external_api_call");
+  }
+  if (effects.size === 0)
+    effects.add("none_detected");
+  return [...effects];
+}
+function inferWriteIntents(productDomain, relPath, sideEffectProfile) {
+  const intents = [];
+  if (productDomain === "booking_creation") {
+    intents.push("create_booking");
+    if (relPath.includes("reschedule") || relPath.includes("Reschedule"))
+      intents.push("reschedule_booking");
+    if (relPath.includes("recurring") || relPath.includes("Recurring"))
+      intents.push("create_recurring_booking");
+  }
+  if (productDomain === "booking_management")
+    intents.push("cancel_booking");
+  if (productDomain === "event_type_configuration")
+    intents.push("update_event_type");
+  if (productDomain === "availability")
+    intents.push("update_availability");
+  if (productDomain === "payments")
+    intents.push("create_payment");
+  if (productDomain === "payments_webhooks")
+    intents.push("handle_payment_webhook");
+  if (productDomain === "auth_oauth") {
+    intents.push("issue_auth_token");
+    intents.push("refresh_auth_token");
+  }
+  if (sideEffectProfile.includes("webhook_delivery"))
+    intents.push("send_webhook");
+  if (productDomain === "settings")
+    intents.push("update_user_settings");
+  if (sideEffectProfile.includes("local_storage") || sideEffectProfile.includes("indexed_db")) {
+    intents.push("persist_local_state");
+  }
+  return intents.length > 0 ? intents : ["none_detected"];
+}
+var ENTRYPOINT_ROLES = /* @__PURE__ */ new Set([
+  "app_route_page",
+  "app_route_handler",
+  "pages_route",
+  "pages_api_route",
+  "trpc_api_route"
+]);
+function inferRiskTypesPass1(rel, frameworkRole, productDomain, sideEffectProfile, gravitySignals, smellKinds) {
+  const types = [];
+  const smThreshold = ["provider", "store"].includes(frameworkRole) ? 8 : 20;
+  if (gravitySignals.cyclomatic > smThreshold)
+    types.push("state_machine");
+  if (smellKinds.has("god-file")) {
+    if (frameworkRole === "hook")
+      types.push("god_hook");
+    else
+      types.push("god_component");
+  }
+  if (sideEffectProfile.length > 3 && !sideEffectProfile.includes("none_detected")) {
+    types.push("side_effect_coupling");
+  }
+  if (productDomain === "forms" && (gravitySignals.fanIn > 3 || gravitySignals.publicSurface > 5))
+    types.push("registry_bottleneck");
+  if (sideEffectProfile.some((s) => ["booking_mutation", "payment_mutation", "auth_token_mutation"].includes(s)) && gravitySignals.cyclomatic > 10)
+    types.push("mutation_orchestration");
+  if (ENTRYPOINT_ROLES.has(frameworkRole) && sideEffectProfile.includes("database_write")) {
+    types.push("route_handler_write_path");
+  }
+  if (smellKinds.has("swallowed-catch"))
+    types.push("error_swallowing");
+  if (sideEffectProfile.includes("local_storage") || sideEffectProfile.includes("indexed_db")) {
+    types.push("storage_persistence_risk");
+  }
+  return types;
+}
+var DOMAIN_SURFACE_PATTERNS = {
+  booking_creation: {
+    expected: [/book/i, /booking/i, /reschedule/i, /booking-success/i, /api\/book/i, /create-booking/i],
+    wrong: [/event-type/i, /event-types/i, /eventtypes/i, /availability/i, /schedule/i]
+  },
+  payments_webhooks: {
+    expected: [/webhook/i, /stripe/i, /payment/i],
+    wrong: [/settings/i, /onboarding/i, /profile/i]
+  },
+  auth_oauth: {
+    expected: [/oauth/i, /callback/i, /auth/i, /signin/i, /login/i],
+    wrong: [/booking/i, /payment/i, /settings/i]
+  }
+};
+function findRuntimeEntrypoints(relPath, importedByMap, persisted, maxDepth = 8) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [{ path: relPath, depth: 0 }];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (seen.has(current.path))
+      continue;
+    seen.add(current.path);
+    if (current.path !== relPath) {
+      const meta = persisted.get(current.path);
+      if (meta && ENTRYPOINT_ROLES.has(meta.frameworkRole)) {
+        results.push({
+          path: current.path,
+          frameworkRole: meta.frameworkRole,
+          productDomain: meta.productDomain,
+          distance: current.depth
+        });
+        if (results.length >= 8)
+          break;
+        continue;
+      }
+    }
+    if (current.depth >= maxDepth)
+      continue;
+    const importers = importedByMap.get(current.path);
+    if (!importers)
+      continue;
+    for (const importer of importers) {
+      if (!seen.has(importer))
+        queue.push({ path: importer, depth: current.depth + 1 });
+    }
+  }
+  const byPath = /* @__PURE__ */ new Map();
+  for (const r of results) {
+    const existing = byPath.get(r.path);
+    if (!existing || r.distance < existing.distance)
+      byPath.set(r.path, r);
+  }
+  return [...byPath.values()].sort((a, b) => a.distance - b.distance);
+}
+function deriveEntrypointTraceStatus(domain, entrypoints, unresolved) {
+  if (entrypoints.length === 0 && unresolved.length > 0)
+    return "blocked_by_alias_resolution";
+  if (entrypoints.length === 0)
+    return "no_runtime_entrypoint_found";
+  const patterns = DOMAIN_SURFACE_PATTERNS[domain];
+  if (patterns) {
+    const allWrong = entrypoints.every((e) => patterns.wrong.some((p) => p.test(e.path)) && !patterns.expected.some((p) => p.test(e.path)));
+    if (allWrong)
+      return "partial_wrong_surface";
+  }
+  return unresolved.length === 0 ? "complete" : "partial";
+}
+function computeLoadBearingScore(gravity, heat, importedByCount, sideEffectProfile, productDomain, smellMaxSeverity, runtimeEntrypoints) {
+  let score = 0;
+  if (gravity >= 85)
+    score += 2;
+  if (heat >= 60)
+    score += 1;
+  if (runtimeEntrypoints.length >= 2)
+    score += 2;
+  if (importedByCount >= 3)
+    score += 1;
+  if (sideEffectProfile.includes("database_write"))
+    score += 3;
+  if (sideEffectProfile.includes("booking_mutation"))
+    score += 3;
+  if (sideEffectProfile.includes("payment_mutation"))
+    score += 3;
+  if (sideEffectProfile.includes("auth_token_mutation"))
+    score += 3;
+  if (sideEffectProfile.includes("webhook_delivery"))
+    score += 2;
+  if (sideEffectProfile.includes("webhook_ingress"))
+    score += 2;
+  if (sideEffectProfile.includes("calendar_mutation"))
+    score += 2;
+  if (sideEffectProfile.includes("redirect"))
+    score += 1;
+  if (sideEffectProfile.includes("analytics_event"))
+    score += 1;
+  const highImpactDomains = [
+    "booking_creation",
+    "payments",
+    "auth_oauth",
+    "webhooks",
+    "payments_webhooks"
+  ];
+  if (highImpactDomains.includes(productDomain))
+    score += 2;
+  if (smellMaxSeverity === 5)
+    score += 3;
+  return score;
 }
 function pageRank(nodes, outEdges, damping = 0.85, iters = 20) {
   const n = nodes.length;
@@ -1053,10 +1649,9 @@ function pageRank(nodes, outEdges, damping = 0.85, iters = 20) {
 function detectCommunities(nodes, adjacency) {
   const label = /* @__PURE__ */ new Map();
   nodes.forEach((node, i) => label.set(node, i));
-  const order = [...nodes];
   for (let pass = 0; pass < 10; pass++) {
     let changed = false;
-    for (const node of order) {
+    for (const node of nodes) {
       const neighbors = adjacency.get(node);
       if (!neighbors || neighbors.size === 0)
         continue;
@@ -1082,164 +1677,174 @@ function detectCommunities(nodes, adjacency) {
   }
   return label;
 }
-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");
-  if (existsSync2(pkgPath)) {
-    try {
-      const pkg = JSON.parse(await readFile4(pkgPath, "utf8"));
-      stack.add("Node.js");
-      const deps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
-      for (const known of ["react", "next", "vue", "svelte", "express", "fastify", "typescript", "vite"]) {
-        if (deps[known])
-          stack.add(known === "next" ? "Next.js" : known[0].toUpperCase() + known.slice(1));
-      }
-      const addEntry = (p) => {
-        if (!p)
-          return;
-        const abs = join4(projectRoot, p);
-        const r = relative(projectRoot, abs);
-        if (files.includes(abs))
-          entrypoints.add(r);
-      };
-      addEntry(pkg.main);
-      if (typeof pkg.bin === "string")
-        addEntry(pkg.bin);
-      else if (pkg.bin)
-        for (const v of Object.values(pkg.bin))
-          addEntry(v);
-    } catch {
-    }
-  }
-  const pyproject = join4(projectRoot, "pyproject.toml");
-  const setupPy = join4(projectRoot, "setup.py");
-  const requirements = join4(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");
-        } catch {
-        }
-      }
-    }
-    for (const known of ["pygame", "PySide6", "PyQt5", "PyQt6", "flask", "django", "fastapi", "numpy", "pandas", "torch", "tensorflow"]) {
-      if (new RegExp(known, "i").test(reqText))
-        stack.add(known);
+function titleCase(s) {
+  return s.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function domainToGroupLabel(domain) {
+  const labels = {
+    booking_creation: "Booking",
+    booking_management: "Booking",
+    booking_audit: "Booking Audit",
+    event_type_configuration: "Event Types",
+    availability: "Availability",
+    auth: "Auth",
+    auth_oauth: "Auth OAuth",
+    payments: "Payments",
+    payments_webhooks: "Payment Webhooks",
+    webhooks: "Webhooks",
+    apps_marketplace: "Apps",
+    calendar_integrations: "Calendar",
+    video: "Video",
+    onboarding: "Onboarding",
+    settings: "Settings",
+    admin: "Admin",
+    data_table: "Data Table",
+    shell_navigation: "Shell",
+    forms: "Forms",
+    embed: "Embed",
+    notifications: "Notifications"
+  };
+  return labels[domain] || titleCase(domain.replace(/_/g, " "));
+}
+function pillarNameFromCluster(files) {
+  const hintCounts = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    if (f.pillarHint && !f.pillarHint.startsWith("community-")) {
+      hintCounts.set(f.pillarHint, (hintCounts.get(f.pillarHint) || 0) + 1);
     }
   }
-  if (existsSync2(join4(projectRoot, "go.mod")))
-    stack.add("Go");
-  if (existsSync2(join4(projectRoot, "Cargo.toml")))
-    stack.add("Rust");
-  if (existsSync2(join4(projectRoot, "pom.xml")) || existsSync2(join4(projectRoot, "build.gradle")))
-    stack.add("Java");
-  for (const abs of files) {
-    const r = rel(abs);
-    const base = basename(r);
-    if (base === "main.py" || base === "__main__.py")
-      entrypoints.add(r);
-    if (/^index\.(ts|tsx|js|jsx|mjs|cjs)$/.test(base) && dirname(r).split(sep).length <= 2)
-      entrypoints.add(r);
-    if (base === "main.go" && r.includes("cmd" + sep))
-      entrypoints.add(r);
-    if (base === "main.go" && !r.includes(sep))
-      entrypoints.add(r);
-    if (base === "main.rs" || base === "lib.rs")
-      entrypoints.add(r);
+  if (hintCounts.size > 0) {
+    const best = [...hintCounts.entries()].sort((a, b) => b[1] - a[1])[0];
+    if (best[1] >= files.length * 0.4)
+      return best[0];
   }
-  if (stack.has("Next.js")) {
-    const appRouterNames = /* @__PURE__ */ new Set(["page", "layout", "route", "loading", "error", "not-found", "template", "default"]);
-    for (const abs of files) {
-      const r = rel(abs);
-      const stem = basename(r, extname(r));
-      const underApp = /(?:^|[/\\])app[/\\]/.test(r);
-      const underPages = /(?:^|[/\\])pages[/\\]/.test(r);
-      if (underApp && appRouterNames.has(stem))
-        entrypoints.add(r);
-      if (underPages && !stem.startsWith("_"))
-        entrypoints.add(r);
+  const dirs = files.map((f) => dirname_simple(f.rel)).filter((d) => d && d !== ".");
+  if (dirs.length) {
+    const segCounts = /* @__PURE__ */ new Map();
+    for (const d of dirs) {
+      const segments = d.split(sep3).filter((s) => !MEANINGLESS_SEGMENTS.has(s.toLowerCase()));
+      const meaningful = segments.pop();
+      if (meaningful)
+        segCounts.set(meaningful, (segCounts.get(meaningful) || 0) + 1);
     }
+    const top = [...segCounts.entries()].sort((a, b) => b[1] - a[1])[0];
+    if (top)
+      return titleCase(top[0]);
   }
-  return { stack: [...stack], entrypoints };
+  const topFile = basename2(files[0].rel, extname3(files[0].rel));
+  return titleCase(topFile);
 }
-var SMELL_WEIGHT = {
-  "todo": 3,
-  "suppression": 5,
-  "swallowed-catch": 10,
-  "deep-nesting": 6,
-  "long-function": 5,
-  "magic-number": 3,
-  "god-file": 14
-};
-function computeHeat(smells) {
-  let sum = 0;
-  for (const s of smells)
-    sum += s.severity * SMELL_WEIGHT[s.kind];
-  return Math.min(100, sum);
+function dirname_simple(p) {
+  const idx = p.lastIndexOf(sep3);
+  if (idx < 0)
+    return ".";
+  return p.slice(0, idx);
 }
-async function scanProject(projectRoot) {
-  await initParser();
-  const abs = [];
-  await collectFiles(projectRoot, projectRoot, abs);
-  const fileSet = new Set(abs.map((f) => relative(projectRoot, f)));
-  const basenameIndex = /* @__PURE__ */ new Map();
-  for (const rel of fileSet) {
-    const b = basename(rel).slice(0, basename(rel).length - extname(rel).length);
-    if (!basenameIndex.has(b))
-      basenameIndex.set(b, []);
-    basenameIndex.get(b).push(rel);
+function buildPillars(classified, communities) {
+  const real = classified.filter((f) => f.isRealSource);
+  const keywordGroups = /* @__PURE__ */ new Map();
+  const unlabeled = [];
+  for (const f of real) {
+    if (f.pillarHint && !f.pillarHint.startsWith("community-")) {
+      if (!keywordGroups.has(f.pillarHint))
+        keywordGroups.set(f.pillarHint, []);
+      keywordGroups.get(f.pillarHint).push(f);
+    } else {
+      unlabeled.push(f);
+    }
   }
-  const { stack, entrypoints } = await detectStackAndEntrypoints(projectRoot, abs);
-  const work = [];
-  const graph = { nodes: {}, edges: [] };
-  for (const file of abs) {
-    const rel = relative(projectRoot, file);
-    const ext = extname(file);
-    const lang = EXT_LANG[ext];
-    if (!lang)
-      continue;
-    let source;
-    try {
-      source = await readFile4(file, "utf8");
-    } catch {
-      continue;
+  const pillars = [];
+  for (const [name, files] of keywordGroups) {
+    const sorted = [...files].sort((a, b) => b.gravity - a.gravity);
+    pillars.push({
+      name,
+      description: `${name} subsystem: ${files.length} file${files.length > 1 ? "s" : ""} centered on ${basename2(sorted[0].rel)}.`,
+      memberFiles: sorted.map((f) => f.rel)
+    });
+  }
+  if (unlabeled.length > 0) {
+    const communityGroups = /* @__PURE__ */ new Map();
+    for (const f of unlabeled) {
+      const c = communities.get(f.rel);
+      if (c === void 0)
+        continue;
+      if (!communityGroups.has(c))
+        communityGroups.set(c, []);
+      communityGroups.get(c).push(f);
     }
-    if (/if\s+__name__\s*==\s*['"]__main__['"]/.test(source) || /^#![^\n]*\b(node|python\d?)\b/.test(source)) {
-      entrypoints.add(rel);
+    const remainingSlots = Math.max(0, 6 - pillars.length);
+    const sorted = [...communityGroups.entries()].map(([id, files]) => ({ id, files, weight: files.reduce((s, f) => s + f.gravity, 0) })).filter((g) => g.files.length >= 2).sort((a, b) => b.weight - a.weight).slice(0, remainingSlots);
+    for (const g of sorted) {
+      const top = [...g.files].sort((a, b) => b.gravity - a.gravity);
+      const name = pillarNameFromCluster(top.map((f) => ({ rel: f.rel, pillarHint: f.pillarHint })));
+      const existing = pillars.find((p) => p.name === name);
+      if (existing) {
+        existing.memberFiles.push(...top.map((f) => f.rel));
+        existing.description = `${name} subsystem: ${existing.memberFiles.length} files.`;
+      } else {
+        pillars.push({
+          name,
+          description: `${g.files.length} files centered on ${basename2(top[0].rel)}.`,
+          memberFiles: top.map((f) => f.rel)
+        });
+      }
     }
-    const tree = await parseAs(lang, source);
-    if (!tree)
-      continue;
-    const ast = analyzeAst(source, lang, tree);
-    const importSpecs = extractImports(source, lang);
-    graph.nodes[rel] = { imports: importSpecs };
-    work.push({ abs: file, rel, lang, source, ast, importSpecs, pathDemote: pathDemoteReason(rel) });
   }
-  const importedBy = /* @__PURE__ */ new Map();
-  const importsResolved = /* @__PURE__ */ new Map();
-  const fanOut = /* @__PURE__ */ new Map();
-  for (const w of work) {
-    importedBy.set(w.rel, /* @__PURE__ */ new Set());
-    importsResolved.set(w.rel, /* @__PURE__ */ new Set());
+  pillars.sort((a, b) => {
+    const gravA = real.filter((f) => a.memberFiles.includes(f.rel)).reduce((s, f) => s + f.gravity, 0);
+    const gravB = real.filter((f) => b.memberFiles.includes(f.rel)).reduce((s, f) => s + f.gravity, 0);
+    return gravB - gravA;
+  });
+  if (pillars.length === 0 && real.length > 0) {
+    pillars.push({ name: "Core", description: "Primary application code.", memberFiles: real.slice(0, 20).map((f) => f.rel) });
   }
-  for (const w of work) {
-    const distinctModules = /* @__PURE__ */ new Set();
-    for (const spec of w.importSpecs) {
-      distinctModules.add(spec);
-      const target = resolveImport(spec, w.abs, w.lang, projectRoot, fileSet, basenameIndex);
-      if (target && target !== w.rel && importedBy.has(target)) {
-        importedBy.get(target).add(w.rel);
-        importsResolved.get(w.rel).add(target);
-        graph.edges.push({ from: w.rel, to: target });
+  const finalPillars = [];
+  for (const p of pillars) {
+    if (p.memberFiles.length > 15) {
+      const groups = /* @__PURE__ */ new Map();
+      for (const rel of p.memberFiles) {
+        const f = classified.find((c) => c.rel === rel);
+        const role = f?.frameworkRole || "unknown";
+        const domain = f?.productDomain || "unknown";
+        let bucket;
+        if (domain !== "unknown" && domain !== "routing_infrastructure" && domain !== "test_infrastructure" && domain !== "generated_noise") {
+          bucket = domainToGroupLabel(domain);
+        } else if (role === "hook") {
+          bucket = "Hooks";
+        } else if (["app_route_page", "app_route_handler", "app_route_layout", "pages_route", "pages_api_route", "trpc_api_route"].includes(role)) {
+          bucket = "Routes";
+        } else if (role === "component") {
+          bucket = "Components";
+        } else {
+          bucket = "Logic";
+        }
+        const key = `${p.name} (${bucket})`;
+        if (!groups.has(key))
+          groups.set(key, []);
+        groups.get(key).push(rel);
+      }
+      for (const [key, files] of groups) {
+        if (files.length > 0)
+          finalPillars.push({ name: key, description: `Subdivided from ${p.name}`, memberFiles: files });
       }
+    } else {
+      finalPillars.push(p);
     }
-    fanOut.set(w.rel, distinctModules.size);
   }
+  const seen = /* @__PURE__ */ new Set();
+  for (const p of finalPillars) {
+    let n = p.name, i = 2;
+    while (seen.has(n)) {
+      n = `${p.name} ${i++}`;
+    }
+    p.name = n;
+    seen.add(n);
+  }
+  return finalPillars;
+}
+async function runClassification(projectRoot, inv, res) {
+  const { work, entrypoints } = inv;
+  const { importedBy, importsResolved, importsUnresolved, fanOut } = res;
   const isRealSource = /* @__PURE__ */ new Map();
   const demoteReason = /* @__PURE__ */ new Map();
   for (const w of work) {
@@ -1256,7 +1861,7 @@ async function scanProject(projectRoot) {
       continue;
     if (entrypoints.has(w.rel))
       continue;
-    const inbound = [...importedBy.get(w.rel)].filter((src) => isRealSource.get(src));
+    const inbound = [...importedBy.get(w.rel) || []].filter((src) => isRealSource.get(src));
     if (inbound.length === 0) {
       isRealSource.set(w.rel, false);
       demoteReason.set(w.rel, "no inbound references from application code");
@@ -1273,12 +1878,12 @@ async function scanProject(projectRoot) {
   for (const w of work) {
     if (!realSet.has(w.rel))
       continue;
-    for (const target of importsResolved.get(w.rel)) {
+    for (const target of importsResolved.get(w.rel) || /* @__PURE__ */ new Set()) {
       if (!realSet.has(target))
         continue;
       outEdges.get(w.rel).add(target);
-      const wDir = w.rel.split(sep)[0];
-      const tDir = target.split(sep)[0];
+      const wDir = w.rel.split(sep3)[0];
+      const tDir = target.split(sep3)[0];
       const weight = wDir === tDir ? 1 : 0.5;
       undirected.get(w.rel).set(target, weight);
       undirected.get(target).set(w.rel, weight);
@@ -1286,13 +1891,26 @@ async function scanProject(projectRoot) {
   }
   const ranks = pageRank(realNodes, outEdges);
   const communities = detectCommunities(realNodes, undirected);
-  const analyses = [];
-  const persisted = {};
+  const metaLookup = /* @__PURE__ */ new Map();
+  const sideEffectsByFile = /* @__PURE__ */ new Map();
+  const writeIntentsByFile = /* @__PURE__ */ new Map();
+  for (const w of work) {
+    const effects = inferSideEffectProfile(w.source, w.importSpecs, w.productDomain, w.frameworkRole);
+    sideEffectsByFile.set(w.rel, effects);
+    writeIntentsByFile.set(w.rel, inferWriteIntents(w.productDomain, w.rel, effects));
+    metaLookup.set(w.rel, { frameworkRole: w.frameworkRole, productDomain: w.productDomain });
+  }
+  const riskTypesByFile = /* @__PURE__ */ new Map();
+  const gravityByFile = /* @__PURE__ */ new Map();
+  const heatByFile = /* @__PURE__ */ new Map();
+  const fanInByFile = /* @__PURE__ */ new Map();
+  const centralityByFile = /* @__PURE__ */ new Map();
+  const gravitySignalsByFile = /* @__PURE__ */ new Map();
   for (const w of work) {
     const real = isRealSource.get(w.rel);
-    const fanIn = [...importedBy.get(w.rel)].filter((src) => isRealSource.get(src)).length;
+    const fanIn = [...importedBy.get(w.rel) || []].filter((src) => isRealSource.get(src)).length;
     const centrality = real ? ranks.get(w.rel) || 0 : 0;
-    const gravitySignals = {
+    const gs = {
       fanIn,
       fanOut: fanOut.get(w.rel) || 0,
       centrality,
@@ -1307,7 +1925,54 @@ async function scanProject(projectRoot) {
     if (!real)
       gravityRaw *= 0.2;
     const gravity = Math.max(0, Math.min(100, gravityRaw));
-    const heatSignals = {
+    const heat = real ? computeHeat(w.ast.smells) : 0;
+    gravityByFile.set(w.rel, gravity);
+    heatByFile.set(w.rel, heat);
+    fanInByFile.set(w.rel, fanIn);
+    centralityByFile.set(w.rel, centrality);
+    gravitySignalsByFile.set(w.rel, gs);
+  }
+  for (const w of work) {
+    const gs = gravitySignalsByFile.get(w.rel);
+    const smellKinds = new Set(w.ast.smells.map((s) => s.kind));
+    const effects = sideEffectsByFile.get(w.rel);
+    const types = inferRiskTypesPass1(w.rel, w.frameworkRole, w.productDomain, effects, gs, smellKinds);
+    riskTypesByFile.set(w.rel, types);
+  }
+  for (const w of work) {
+    if (w.productDomain === "forms" && (w.frameworkRole === "component" || w.frameworkRole === "hook")) {
+      const importsResolved_w = importsResolved.get(w.rel) || /* @__PURE__ */ new Set();
+      const importsAny = [...importsResolved_w, ...w.importSpecs.filter((s) => s.startsWith("@"))];
+      const consumesBottleneck = importsAny.some((dep) => {
+        const types2 = riskTypesByFile.get(dep);
+        return types2?.includes("registry_bottleneck");
+      });
+      if (consumesBottleneck) {
+        const existing = riskTypesByFile.get(w.rel);
+        if (!existing.includes("registry_consumer"))
+          existing.push("registry_consumer");
+        if (!existing.includes("type_boundary_leak"))
+          existing.push("type_boundary_leak");
+        const idx = existing.indexOf("complexity_hotspot");
+        if (idx >= 0)
+          existing.splice(idx, 1);
+      }
+    }
+    const types = riskTypesByFile.get(w.rel);
+    if (types.length === 0)
+      types.push("complexity_hotspot");
+  }
+  const classified = [];
+  for (const w of work) {
+    const real = isRealSource.get(w.rel);
+    const fanIn = fanInByFile.get(w.rel);
+    const gravity = gravityByFile.get(w.rel);
+    const heat = heatByFile.get(w.rel);
+    const gs = gravitySignalsByFile.get(w.rel);
+    const effects = sideEffectsByFile.get(w.rel);
+    const writeIntents = writeIntentsByFile.get(w.rel);
+    const riskTypes = riskTypesByFile.get(w.rel);
+    const hs = {
       todos: w.ast.smells.filter((s) => s.kind === "todo").length,
       suppressions: w.ast.smells.filter((s) => s.kind === "suppression").length,
       swallowedCatches: w.ast.swallowedCatches,
@@ -1315,208 +1980,532 @@ async function scanProject(projectRoot) {
       longFunctions: w.ast.longFunctions,
       magicNumbers: w.ast.magicNumbers
     };
-    const heat = real ? computeHeat(w.ast.smells) : 0;
     const keywordPillar = matchPillarByImports(w.importSpecs);
     const pathPillar = matchPillarByPath(w.rel);
     const pillarHint = real ? keywordPillar || pathPillar || `community-${communities.get(w.rel)}` : null;
-    const fa = {
-      path: w.abs,
-      relativePath: w.rel,
-      language: w.lang,
-      isRealSource: real,
-      demoteReason: demoteReason.get(w.rel) || null,
-      gravity,
-      heat,
-      gravitySignals,
-      heatSignals,
-      smells: w.ast.smells,
-      pillarHint
-    };
-    analyses.push(fa);
-    persisted[w.rel] = {
-      relativePath: w.rel,
-      language: w.lang,
+    const importedByReal = [...importedBy.get(w.rel) || []].filter((src) => isRealSource.get(src));
+    const imports = [...importsResolved.get(w.rel) || /* @__PURE__ */ new Set()];
+    const importsUnresolvedArr = [...importsUnresolved.get(w.rel) || /* @__PURE__ */ new Set()];
+    const runtimeEntrypoints = findRuntimeEntrypoints(w.rel, importedBy, metaLookup);
+    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);
+    classified.push({
+      rel: w.rel,
+      abs: w.abs,
+      lang: w.lang,
       isRealSource: real,
       demoteReason: demoteReason.get(w.rel) || null,
       gravity,
       heat,
-      gravitySignals,
-      heatSignals,
+      gravitySignals: gs,
+      heatSignals: hs,
       smells: w.ast.smells,
       pillarHint,
-      importedBy: [...importedBy.get(w.rel)].filter((src) => isRealSource.get(src)),
-      imports: [...importsResolved.get(w.rel)]
-    };
+      importedBy: importedByReal,
+      imports,
+      importsUnresolved: importsUnresolvedArr,
+      frameworkRole: w.frameworkRole,
+      productDomain: w.productDomain,
+      sideEffectProfile: effects,
+      writeIntents,
+      riskTypes,
+      runtimeEntrypoints,
+      entrypointTraceStatus,
+      blockedImports: importsUnresolvedArr,
+      loadBearingScore,
+      hotSpans: w.ast.hotSpans,
+      source: w.source
+    });
   }
-  const realAnalyses = analyses.filter((a) => a.isRealSource).sort((a, b) => b.gravity - a.gravity);
-  const wildCandidates = realAnalyses.filter((a) => a.heat >= 60 || a.smells.some((s) => s.severity >= 4)).sort((a, b) => b.heat - a.heat);
-  const pillars = buildPillars(realAnalyses, communities, stack);
-  const topGravity = realAnalyses.slice(0, 12).map((a) => a.relativePath);
-  const topHeat = wildCandidates.slice(0, 12).map((a) => a.relativePath);
+  const dir = join6(projectRoot, ".vibe-splainer");
+  await mkdir5(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");
+  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");
+  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");
+  const stage08 = Object.fromEntries(classified.map((f) => [f.rel, {
+    isLoadBearing: f.loadBearingScore >= 5,
+    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");
+  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);
   const map = {
-    stack,
+    stack: inv.stack,
     entrypoints: [...entrypoints],
     pillars,
     fileCount: work.length,
-    realSourceCount: realAnalyses.length,
-    topGravity,
-    topHeat,
+    realSourceCount: realClassified.length,
+    topGravity: realClassified.slice(0, 12).map((f) => f.rel),
+    topHeat: wildCandidates.slice(0, 12).map((f) => f.rel),
     brief: null
   };
-  await writeGraph(projectRoot, graph);
-  const analysisStore = { files: persisted };
-  await writeAnalysis(projectRoot, analysisStore);
-  await writeDeltaTargets(projectRoot, analysisStore, entrypoints);
-  const uiUrl = `file://${join4(projectRoot, ".vibe-splainer", "ui", "index.html")}`;
-  return {
-    projectRoot,
-    totalFilesScanned: work.length,
-    realSourceCount: realAnalyses.length,
-    files: realAnalyses,
-    map,
-    wildCandidates,
-    uiUrl,
-    graph
-  };
+  return { projectRoot, classified, stack: inv.stack, entrypoints, map, communities };
 }
-function buildPillars(real, communities, _stack) {
-  const keywordGroups = /* @__PURE__ */ new Map();
-  const unlabeled = [];
-  for (const a of real) {
-    if (a.pillarHint && !a.pillarHint.startsWith("community-")) {
-      if (!keywordGroups.has(a.pillarHint))
-        keywordGroups.set(a.pillarHint, []);
-      keywordGroups.get(a.pillarHint).push(a);
-    } else {
-      unlabeled.push(a);
-    }
+
+// ../brain/dist/pipeline/scoring.js
+import { join as join7 } from "path";
+import { writeFile as writeFile7, mkdir as mkdir6 } from "fs/promises";
+import { createHash } from "crypto";
+function computeSeverity(sideEffectProfile, productDomain, gravity, heat, maxNesting, hasLongFunctions, swallowedCatches, runtimeEntrypoints) {
+  let score = 0;
+  if (sideEffectProfile.includes("database_write"))
+    score += 3;
+  if (sideEffectProfile.includes("booking_mutation"))
+    score += 4;
+  if (sideEffectProfile.includes("payment_mutation"))
+    score += 4;
+  if (sideEffectProfile.includes("auth_token_mutation"))
+    score += 4;
+  if (sideEffectProfile.includes("webhook_delivery"))
+    score += 3;
+  if (sideEffectProfile.includes("webhook_ingress"))
+    score += 3;
+  if (sideEffectProfile.includes("calendar_mutation"))
+    score += 3;
+  if (productDomain === "booking_creation")
+    score += 3;
+  if (productDomain === "payments" || productDomain === "payments_webhooks")
+    score += 3;
+  if (productDomain === "auth_oauth")
+    score += 3;
+  if (productDomain === "webhooks")
+    score += 2;
+  if (gravity >= 85)
+    score += 2;
+  if (heat >= 70)
+    score += 2;
+  if (maxNesting >= 4)
+    score += 1;
+  if (hasLongFunctions)
+    score += 1;
+  if (swallowedCatches >= 1)
+    score += 1;
+  if (runtimeEntrypoints.length >= 2)
+    score += 2;
+  if (score >= 10)
+    return 5;
+  if (score >= 7)
+    return 4;
+  if (score >= 4)
+    return 3;
+  if (score >= 2)
+    return 2;
+  return 1;
+}
+function applyCorrections(file) {
+  if (file.writeIntents.includes("handle_payment_webhook")) {
+    if (!file.sideEffectProfile.includes("payment_mutation"))
+      file.sideEffectProfile.push("payment_mutation");
+    if (!file.sideEffectProfile.includes("webhook_ingress"))
+      file.sideEffectProfile.push("webhook_ingress");
+    file.sideEffectProfile = file.sideEffectProfile.filter((s) => s !== "none_detected");
+  }
+  if (file.sideEffectProfile.includes("payment_mutation") || file.sideEffectProfile.includes("booking_mutation")) {
+    if (file.canonicalSeverity < 4)
+      file.canonicalSeverity = 4;
+  }
+  if (file.canonicalSeverity === 5)
+    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");
+  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.`
+    };
   }
-  const pillars = [];
-  for (const [name, files] of keywordGroups) {
-    const sorted = [...files].sort((a, b) => b.gravity - a.gravity);
-    pillars.push({
-      name,
-      description: `${name} subsystem: ${files.length} file${files.length > 1 ? "s" : ""} centered on ${basename(sorted[0].relativePath)}.`,
-      memberFiles: sorted.map((f) => f.relativePath)
+  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 (loadBearingScore >= 5 || importedByCount >= 5) {
+    return { level: "medium", reason: `Imported by ${importedByCount} files. Interface changes will cascade.` };
+  }
+  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 (unlabeled.length > 0) {
-    const communityGroups = /* @__PURE__ */ new Map();
-    for (const a of unlabeled) {
-      const c = communities.get(a.relativePath);
-      if (c === void 0)
-        continue;
-      if (!communityGroups.has(c))
-        communityGroups.set(c, []);
-      communityGroups.get(c).push(a);
-    }
-    const remainingSlots = Math.max(0, 6 - pillars.length);
-    const sorted = [...communityGroups.entries()].map(([id, files]) => ({ id, files, weight: files.reduce((s, f) => s + f.gravity, 0) })).filter((g) => g.files.length >= 2).sort((a, b) => b.weight - a.weight).slice(0, remainingSlots);
-    for (const g of sorted) {
-      const top = [...g.files].sort((a, b) => b.gravity - a.gravity);
-      const name = pillarNameFromCluster(top);
-      const existing = pillars.find((p) => p.name === name);
-      if (existing) {
-        existing.memberFiles.push(...top.map((f) => f.relativePath));
-        existing.description = `${name} subsystem: ${existing.memberFiles.length} files centered on ${basename(existing.memberFiles[0])}.`;
-      } else {
-        pillars.push({
-          name,
-          description: `${g.files.length} files centered on ${basename(top[0].relativePath)}.`,
-          memberFiles: top.map((f) => f.relativePath)
-        });
-      }
-    }
+  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))
+    });
   }
-  pillars.sort((a, b) => {
-    const gravA = real.filter((f) => a.memberFiles.includes(f.relativePath)).reduce((s, f) => s + f.gravity, 0);
-    const gravB = real.filter((f) => b.memberFiles.includes(f.relativePath)).reduce((s, f) => s + f.gravity, 0);
-    return gravB - gravA;
-  });
-  if (pillars.length === 0 && real.length > 0) {
-    pillars.push({ name: "Core", description: "Primary application code.", memberFiles: real.slice(0, 20).map((f) => f.relativePath) });
+  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))
+    });
   }
-  const finalPillars = [];
-  for (const p of pillars) {
-    if (p.memberFiles.length > 15) {
-      const groups = /* @__PURE__ */ new Map();
-      for (const f of p.memberFiles) {
-        let bucket = "Core";
-        if (f.includes("app/") || f.includes("pages/") || f.includes("routes/"))
-          bucket = "Routing";
-        else if (f.includes("components/") || f.includes("ui/"))
-          bucket = "Components";
-        else if (f.includes("hooks/") || f.includes("lib/") || f.includes("utils/"))
-          bucket = "Logic";
-        const d = basename(dirname(f));
-        const key = `${p.name} (${bucket} - ${d})`;
-        if (!groups.has(key))
-          groups.set(key, []);
-        groups.get(key).push(f);
-      }
-      for (const [key, files] of groups) {
-        if (files.length > 0) {
-          finalPillars.push({
-            name: key,
-            description: `Subdivided from ${p.name}`,
-            memberFiles: files
-          });
-        }
-      }
-    } else {
-      finalPillars.push(p);
-    }
+  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))
+    });
   }
-  const seen = /* @__PURE__ */ new Set();
-  for (const p of finalPillars) {
-    let n = p.name, i = 2;
-    while (seen.has(n)) {
-      n = `${p.name} ${i++}`;
-    }
-    p.name = n;
-    seen.add(n);
+  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 finalPillars;
+  return probes;
 }
-function pillarNameFromCluster(files) {
-  const hintCounts = /* @__PURE__ */ new Map();
-  for (const f of files) {
-    if (f.pillarHint && !f.pillarHint.startsWith("community-")) {
-      hintCounts.set(f.pillarHint, (hintCounts.get(f.pillarHint) || 0) + 1);
-    }
+function deriveConfidence(fanIn, gravity) {
+  if (fanIn >= 10 && gravity >= 40)
+    return "high";
+  if (fanIn >= 5 || gravity >= 25)
+    return "medium";
+  return "low";
+}
+async function runScoring(projectRoot, cr) {
+  const dir = join7(projectRoot, ".vibe-splainer");
+  await mkdir6(dir, { recursive: true });
+  const persisted = {};
+  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 pf = {
+      relativePath: f.rel,
+      language: f.lang,
+      isRealSource: f.isRealSource,
+      demoteReason: f.demoteReason,
+      gravity: Math.round(f.gravity),
+      heat: Math.round(f.heat),
+      gravitySignals: f.gravitySignals,
+      heatSignals: f.heatSignals,
+      smells: f.smells,
+      pillarHint: f.pillarHint,
+      importedBy: f.importedBy,
+      imports: f.imports,
+      importsUnresolved: f.importsUnresolved,
+      frameworkRole: f.frameworkRole,
+      productDomain: f.productDomain,
+      sideEffectProfile: f.sideEffectProfile,
+      hotSpans: f.hotSpans,
+      riskTypes: f.riskTypes,
+      writeIntents: f.writeIntents,
+      canonicalSeverity: severity,
+      canonicalLoadBearing: isLoadBearing
+    };
+    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 writeFile7(join7(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.snippet,
+      evidenceHash: createHash("sha256").update(span.snippet).digest("hex").slice(0, 12)
+    }));
+    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,
+      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 tmp = dest + ".tmp";
+  await writeFile7(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");
+  for (const e of validationReport.errors) {
+    console.error(`[vibe-splain] VALIDATION ERROR [${e.rule}] ${e.file}: ${e.detail}`);
   }
-  if (hintCounts.size > 0) {
-    const best = [...hintCounts.entries()].sort((a, b) => b[1] - a[1])[0];
-    if (best[1] >= files.length * 0.4)
-      return best[0];
+  for (const w of validationReport.warnings) {
+    console.error(`[vibe-splain] VALIDATION WARN [${w.rule}] ${w.file}: ${w.detail}`);
   }
-  const dirs = files.map((f) => dirname(f.relativePath)).filter((d) => d && d !== ".");
-  if (dirs.length) {
-    const segCounts = /* @__PURE__ */ new Map();
-    for (const d of dirs) {
-      const segments = d.split(sep).filter((s) => !MEANINGLESS_SEGMENTS.has(s.toLowerCase()));
-      const meaningful = segments.pop();
-      if (meaningful)
-        segCounts.set(meaningful, (segCounts.get(meaningful) || 0) + 1);
+  return { store, deltaTargets, validationReport };
+}
+function buildValidationReport(store, deltaTargets) {
+  const errors = [];
+  const warnings = [];
+  let passCount = 0;
+  const deltaByPath = new Map(deltaTargets.map((d) => [d.path, d]));
+  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;
     }
-    const top = [...segCounts.entries()].sort((a, b) => b[1] - a[1])[0];
-    if (top)
-      return titleCase(top[0]);
+    if (pf.writeIntents.includes("handle_payment_webhook") && pf.sideEffectProfile.includes("none_detected")) {
+      errors.push({
+        file: pf.relativePath,
+        rule: "payment_webhook_no_effects",
+        detail: "writeIntents includes handle_payment_webhook but sideEffectProfile is none_detected",
+        expected: "payment_mutation + webhook_ingress",
+        actual: "none_detected"
+      });
+      continue;
+    }
+    if (pf.productDomain === "booking_creation" && delta?.entrypointTraceStatus === "no_runtime_entrypoint_found" && pf.importsUnresolved.length === 0) {
+      errors.push({
+        file: pf.relativePath,
+        rule: "booking_creation_no_entrypoint_no_blockers",
+        detail: "booking_creation domain with no entrypoint found and no blocked imports \u2014 classification may be wrong"
+      });
+      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) {
+      errors.push({
+        file: pf.relativePath,
+        rule: "high_severity_no_evidence",
+        detail: `severity=${pf.canonicalSeverity} but rawEvidence is empty`
+      });
+      continue;
+    }
+    if (pf.canonicalSeverity >= 4 && (delta?.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(", ");
+      warnings.push({
+        file: pf.relativePath,
+        rule: "partial_wrong_surface",
+        detail: `Entrypoints found but domain surface mismatch for ${pf.productDomain}. Found: ${foundPaths}`
+      });
+    }
+    passCount++;
   }
-  const topFile = basename(files[0].relativePath, extname(files[0].relativePath));
-  return titleCase(topFile);
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    passed: errors.length === 0,
+    errors,
+    warnings,
+    summary: { errorCount: errors.length, warningCount: warnings.length, passCount }
+  };
 }
-function titleCase(s) {
-  return s.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+
+// ../brain/dist/pipeline/orchestrator.js
+async function runPipeline(projectRoot) {
+  const inv = await runInventory(projectRoot);
+  const res = await runResolution(projectRoot, inv);
+  const cr = await runClassification(projectRoot, inv, res);
+  const scoring = await runScoring(projectRoot, cr);
+  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,
+    language: f.lang,
+    isRealSource: f.isRealSource,
+    demoteReason: f.demoteReason,
+    gravity: Math.round(f.gravity),
+    heat: Math.round(f.heat),
+    gravitySignals: f.gravitySignals,
+    heatSignals: f.heatSignals,
+    smells: f.smells,
+    pillarHint: f.pillarHint,
+    frameworkRole: f.frameworkRole,
+    productDomain: f.productDomain,
+    sideEffectProfile: f.sideEffectProfile
+  }));
+  const wildCandidates = cr.classified.filter((f) => f.isRealSource && (f.heat >= 60 || f.smells.some((s) => s.severity >= 4))).sort((a, b) => b.heat - a.heat).map((f) => ({
+    path: f.abs,
+    relativePath: f.rel,
+    language: f.lang,
+    isRealSource: f.isRealSource,
+    demoteReason: f.demoteReason,
+    gravity: Math.round(f.gravity),
+    heat: Math.round(f.heat),
+    gravitySignals: f.gravitySignals,
+    heatSignals: f.heatSignals,
+    smells: f.smells,
+    pillarHint: f.pillarHint,
+    frameworkRole: f.frameworkRole,
+    productDomain: f.productDomain,
+    sideEffectProfile: f.sideEffectProfile
+  }));
+  const uiUrl = `file://${join8(projectRoot, ".vibe-splainer", "ui", "index.html")}`;
+  return {
+    projectRoot,
+    totalFilesScanned: cr.classified.length,
+    realSourceCount: files.length,
+    files,
+    map: cr.map,
+    wildCandidates,
+    uiUrl,
+    graph: res.graph,
+    validation: {
+      passed: scoring.validationReport.passed,
+      errors: scoring.validationReport.summary.errorCount,
+      warnings: scoring.validationReport.summary.warningCount,
+      reportPath: ".vibe-splainer/validation_report.json"
+    }
+  };
+}
+
+// ../brain/dist/scanner.js
+async function initParser2() {
+  return initParser();
+}
+async function scanProject(projectRoot) {
+  return runPipeline(projectRoot);
 }
 async function getFileAnalysis(absPath) {
-  const ext = extname(absPath);
+  const ext = extname4(absPath);
   const lang = EXT_LANG[ext];
   if (!lang)
     return null;
   let source;
   try {
-    source = await readFile4(absPath, "utf8");
+    source = await readFile6(absPath, "utf8");
   } catch {
     return null;
   }
@@ -1535,20 +2524,19 @@ async function getFileAnalysis(absPath) {
       reason: `${s.kind}: ${s.note}`
     };
   });
-  const heatSignals = {
-    todos: ast.smells.filter((s) => s.kind === "todo").length,
-    suppressions: ast.smells.filter((s) => s.kind === "suppression").length,
-    swallowedCatches: ast.swallowedCatches,
-    maxNesting: ast.maxNesting,
-    longFunctions: ast.longFunctions,
-    magicNumbers: ast.magicNumbers
-  };
   return {
     language: lang,
     signature: ast.signature,
     hotSpans: ast.hotSpans,
     smellSpans,
-    heatSignals,
+    heatSignals: {
+      todos: ast.smells.filter((s) => s.kind === "todo").length,
+      suppressions: ast.smells.filter((s) => s.kind === "suppression").length,
+      swallowedCatches: ast.swallowedCatches,
+      maxNesting: ast.maxNesting,
+      longFunctions: ast.longFunctions,
+      magicNumbers: ast.magicNumbers
+    },
     loc: ast.loc,
     cyclomatic: ast.cyclomatic
   };
@@ -1556,16 +2544,16 @@ async function getFileAnalysis(absPath) {
 
 // ../brain/dist/dossier.js
 import { Mutex } from "async-mutex";
-import { join as join5, dirname as dirname2 } from "path";
+import { join as join9, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { readFile as readFile5, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync3, cpSync } from "fs";
-var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+import { readFile as readFile7, writeFile as writeFile8, 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 = join5(projectRoot, ".vibe-splainer", "dossier.json");
+  const dossierPath = join9(projectRoot, ".vibe-splainer", "dossier.json");
   try {
-    const raw = await readFile5(dossierPath, "utf8");
+    const raw = await readFile7(dossierPath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -1577,33 +2565,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 = join5(projectRoot, ".vibe-splainer");
-    await mkdir3(dir, { recursive: true });
-    const dossierPath = join5(dir, "dossier.json");
+    const dir = join9(projectRoot, ".vibe-splainer");
+    await mkdir7(dir, { recursive: true });
+    const dossierPath = join9(dir, "dossier.json");
     const tmp = dossierPath + ".tmp";
-    await writeFile4(tmp, JSON.stringify(dossier, null, 2), "utf8");
+    await writeFile8(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 = join5(projectRoot, ".vibe-splainer", "ui");
-  await mkdir3(uiDir, { recursive: true });
-  let templateDir = join5(__dirname2, "ui");
-  if (!existsSync3(templateDir)) {
-    templateDir = join5(__dirname2, "../../cli/dist/ui");
+  const uiDir = join9(projectRoot, ".vibe-splainer", "ui");
+  await mkdir7(uiDir, { recursive: true });
+  let templateDir = join9(__dirname2, "ui");
+  if (!existsSync4(templateDir)) {
+    templateDir = join9(__dirname2, "../../cli/dist/ui");
   }
-  if (!existsSync3(templateDir)) {
+  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 readFile5(join5(templateDir, "index.html"), "utf8");
+  let html = await readFile7(join9(templateDir, "index.html"), "utf8");
   const injection = `<script>window.__VIBE_DOSSIER__ = ${JSON.stringify(dossier)};</script>`;
   html = html.replace("<!-- VIBE_DOSSIER_INJECTION_POINT -->", injection);
-  await writeFile4(join5(uiDir, "index.html"), html, "utf8");
-  console.error("[vibe-splain] UI regenerated at", join5(uiDir, "index.html"));
+  await writeFile8(join9(uiDir, "index.html"), html, "utf8");
+  console.error("[vibe-splain] UI regenerated at", join9(uiDir, "index.html"));
 }
 function validateMermaidNodeCount(diagram) {
   if (!diagram)
@@ -1622,9 +2610,9 @@ function validateMermaidNodeCount(diagram) {
 
 // ../brain/dist/watcher.js
 import chokidar from "chokidar";
-import { createHash } from "crypto";
-import { readFile as readFile6 } from "fs/promises";
-import { join as join6 } from "path";
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile8 } from "fs/promises";
+import { join as join10 } from "path";
 function startWatcher(projectRoot, watchedPaths) {
   const watcher = chokidar.watch(watchedPaths.length > 0 ? watchedPaths : projectRoot, {
     ignoreInitial: true,
@@ -1636,14 +2624,14 @@ function startWatcher(projectRoot, watchedPaths) {
       const dossier = await readDossier(projectRoot);
       if (!dossier)
         return;
-      const content = await readFile6(filepath, "utf8");
-      const newHash = createHash("sha256").update(content).digest("hex");
+      const content = await readFile8(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 === join6(projectRoot, card.primaryFile) || filepath.endsWith("/" + card.primaryFile);
+          const absMatch = filepath === join10(projectRoot, card.primaryFile) || filepath.endsWith("/" + card.primaryFile);
           if (absMatch && card.lastScannedHash !== newHash) {
             card.status = "stale";
             const rel = card.primaryFile;
@@ -1702,7 +2690,22 @@ async function handleScanProject(args) {
   await writeDossier(projectRoot, dossier);
   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" };
   return {
+    ok: true,
+    validation: {
+      passed: validation.passed,
+      errors: validation.errors,
+      warnings: validation.warnings,
+      reportPath: validation.reportPath
+    },
+    artifacts: {
+      analysis: ".vibe-splainer/analysis.json",
+      deltaTargets: ".vibe-splainer/delta_targets.json",
+      dossier: ".vibe-splainer/dossier.json",
+      graph: ".vibe-splainer/graph.json",
+      html: ".vibe-splainer/ui/index.html"
+    },
     projectRoot: result.projectRoot,
     totalFilesScanned: result.totalFilesScanned,
     realSourceCount: result.realSourceCount,
@@ -1798,8 +2801,8 @@ async function handleSetProjectBrief(args) {
 }
 
 // dist/mcp/tools/get_file_context.js
-import { readFile as readFile7 } from "fs/promises";
-import { join as join7, relative as relative2, isAbsolute } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join11, 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.",
@@ -1819,8 +2822,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 : join7(projectRoot, filePath);
-  const relPath = relative2(projectRoot, fullPath);
+  const fullPath = isAbsolute(filePath) ? filePath : join11(projectRoot, filePath);
+  const relPath = relative3(projectRoot, fullPath);
   const evidence = await getFileAnalysis(fullPath);
   if (!evidence) {
     throw new Error(`Could not analyze ${relPath} (unsupported language or parse failure).`);
@@ -1844,16 +2847,16 @@ async function handleGetFileContext(args) {
     smellSpans: evidence.smellSpans
   };
   if (full) {
-    result.source = await readFile7(fullPath, "utf8");
+    result.source = await readFile9(fullPath, "utf8");
   }
   return result;
 }
 
 // dist/mcp/tools/write_decision_card.js
 import { v4 as uuidv4 } from "uuid";
-import { createHash as createHash2 } from "crypto";
-import { readFile as readFile8 } from "fs/promises";
-import { join as join8 } from "path";
+import { createHash as createHash3 } from "crypto";
+import { readFile as readFile10 } from "fs/promises";
+import { join as join12 } from "path";
 var CATEGORIES = ["Bottleneck", "Hack", "Smart-Move", "Risk", "Convention", "Dead-Weight"];
 function normalizeSnippet(s) {
   let out = (s ?? "").replace(/\r\n/g, "\n");
@@ -1945,10 +2948,10 @@ async function handleWriteDecisionCard(args) {
   const heat = persisted ? Math.round(persisted.heat) : void 0;
   let primaryContent = "";
   try {
-    primaryContent = await readFile8(join8(projectRoot, primaryFile), "utf8");
+    primaryContent = await readFile10(join12(projectRoot, primaryFile), "utf8");
   } catch {
   }
-  const hash = createHash2("sha256").update(primaryContent).digest("hex");
+  const hash = createHash3("sha256").update(primaryContent).digest("hex");
   const card = {
     id: uuidv4(),
     pillar,
@@ -2189,7 +3192,7 @@ var TOOL_HANDLERS = {
   mark_stale: handleMarkStale
 };
 async function startMCPServer() {
-  await initParser();
+  await initParser2();
   console.error("[vibe-splain] Tree-Sitter parser initialized");
   const server = new Server({ name: "vibe-splain", version: "2.0.0" }, { capabilities: { tools: {}, prompts: {} } });
   server.setRequestHandler(ListPromptsRequestSchema, async () => ({
@@ -2314,7 +3317,7 @@ async function serveCommand() {
 
 // dist/index.js
 var program = new Command();
-program.name("vibe-splain").description("Architectural dossier engine for vibe-coded projects").version("2.3.1");
+program.name("vibe-splain").description("Architectural dossier engine for vibe-coded projects").version("2.5.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.parse();