vibe-splain 2.4.1 → 2.6.0

package/dist/index.js

@@ -19,8 +19,9 @@ function expandPath(p) {
   return p;
 }
 var AGENT_CONFIGS = [
-  { name: "Claude Code", path: "~/.claude/claude_desktop_config.json", format: "claude" },
-  { name: "Claude Code (Windows)", path: "%APPDATA%/Claude/claude_desktop_config.json", format: "claude" },
+  { name: "Claude Code CLI", path: "~/.claude/settings.json", format: "claude" },
+  { name: "Claude Desktop", path: "~/.claude/claude_desktop_config.json", format: "claude" },
+  { name: "Claude Desktop (Windows)", path: "%APPDATA%/Claude/claude_desktop_config.json", format: "claude" },
   { name: "Gemini CLI", path: "~/.gemini/settings.json", format: "gemini" },
   { name: "Cursor", path: "~/.cursor/mcp.json", format: "cursor" },
   { name: "Windsurf", path: "~/.codeium/windsurf/mcp_config.json", format: "cursor" }
@@ -87,12 +88,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 readFile7 } from "fs/promises";
+
+// ../brain/dist/pipeline/orchestrator.js
+import { join as join8 } from "path";
 
 // ../brain/dist/graph.js
 import { join as join2 } from "path";
@@ -106,7 +106,6 @@ async function writeGraph(projectRoot, graph) {
 
 // ../brain/dist/analysis.js
 import { join as join3 } from "path";
-import { createHash } from "crypto";
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
 async function readAnalysis(projectRoot) {
   const p = join3(projectRoot, ".vibe-splainer", "analysis.json");
@@ -126,575 +125,279 @@ async function writeAnalysis(projectRoot, store) {
   const { rename } = await import("fs/promises");
   await rename(tmp, dest);
 }
-var ENTRYPOINT_ROLES = /* @__PURE__ */ new Set([
-  "app_route_page",
-  "app_route_handler",
-  "pages_route",
-  "pages_api_route",
-  "trpc_api_route"
+
+// ../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 langCache = /* @__PURE__ */ new Map();
+var EXT_LANG = {
+  ".ts": "typescript",
+  ".tsx": "tsx",
+  ".js": "javascript",
+  ".jsx": "tsx",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java"
+};
+var LANG_WASM = {
+  typescript: "tree-sitter-typescript.wasm",
+  tsx: "tree-sitter-tsx.wasm",
+  javascript: "tree-sitter-javascript.wasm",
+  python: "tree-sitter-python.wasm",
+  go: "tree-sitter-go.wasm",
+  rust: "tree-sitter-rust.wasm",
+  java: "tree-sitter-java.wasm"
+};
+var SUPPORTED_EXTENSIONS = new Set(Object.keys(EXT_LANG));
+function resolveWasm(file) {
+  try {
+    const wasmsDir = dirname(require2.resolve("tree-sitter-wasms/package.json"));
+    const p = join4(wasmsDir, "out", file);
+    if (existsSync2(p))
+      return p;
+  } catch {
+  }
+  const local = join4(__dirname, "../../wasm", file);
+  return existsSync2(local) ? local : null;
+}
+async function getLanguage(lang) {
+  const cached = langCache.get(lang);
+  if (cached)
+    return cached;
+  const wasm = resolveWasm(LANG_WASM[lang]);
+  if (!wasm) {
+    console.error(`[vibe-splain] grammar missing for ${lang} (${LANG_WASM[lang]}); skipping`);
+    return null;
+  }
+  try {
+    const loaded = await Parser.Language.load(wasm);
+    langCache.set(lang, loaded);
+    return loaded;
+  } catch (err) {
+    console.error(`[vibe-splain] failed to load grammar for ${lang}:`, err instanceof Error ? err.message : err);
+    return null;
+  }
+}
+async function initParser() {
+  if (_parser)
+    return _parser;
+  await Parser.init();
+  _parser = new Parser();
+  const ts = await getLanguage("typescript");
+  if (ts)
+    _parser.setLanguage(ts);
+  return _parser;
+}
+async function parseAs(lang, source) {
+  const p = await initParser();
+  const language = await getLanguage(lang);
+  if (!language)
+    return null;
+  p.setLanguage(language);
+  try {
+    return p.parse(source);
+  } catch {
+    return null;
+  }
+}
+var EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".next",
+  "out",
+  ".vibe-splainer",
+  ".git",
+  ".venv",
+  "venv",
+  "env",
+  "__pycache__",
+  ".idea",
+  ".vscode",
+  ".cache",
+  "site-packages",
+  "target",
+  ".tox",
+  ".mypy_cache",
+  ".pytest_cache"
 ]);
-function findRuntimeEntrypoints(relPath, files, 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 meta2 = files[current.path];
-      if (meta2 && ENTRYPOINT_ROLES.has(meta2.frameworkRole)) {
-        results.push({
-          path: current.path,
-          frameworkRole: meta2.frameworkRole,
-          productDomain: meta2.productDomain,
-          distance: current.depth
-        });
-        if (results.length >= 8)
-          break;
+var EXCLUDE_FILE_PATTERNS = [/\.lock$/, /\.min\.[a-z]+$/, /\.d\.ts$/];
+var DEMOTE_SEGMENTS = /* @__PURE__ */ new Set([
+  "docs",
+  "doc",
+  "examples",
+  "example",
+  "samples",
+  "sample",
+  "mockup",
+  "mockups",
+  "fixtures",
+  "fixture",
+  "__generated__",
+  "__mocks__",
+  "playwright",
+  "e2e",
+  "__tests__",
+  "cypress",
+  "storybook",
+  "stories",
+  ".storybook"
+]);
+var VENDOR_SEGMENTS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "vendor",
+  "vendored",
+  "site-packages",
+  "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 (current.depth >= maxDepth)
-      continue;
-    const meta = files[current.path];
-    if (!meta)
+    if (EXCLUDE_DIRS.has(entry.name))
       continue;
-    for (const importer of meta.importedBy) {
-      if (!seen.has(importer)) {
-        queue.push({ path: importer, depth: current.depth + 1 });
-      }
+    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);
     }
   }
-  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);
+}
+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";
   }
-  return [...byPath.values()].sort((a, b) => a.distance - b.distance);
+  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 deriveEntrypointTraceStatus(entrypoints, unresolved) {
-  if (entrypoints.length > 0 && unresolved.length === 0)
-    return "complete";
-  if (entrypoints.length > 0)
-    return "partial";
-  if (unresolved.length > 0)
-    return "blocked_by_alias_resolution";
-  return "no_runtime_entrypoint_found";
+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 computeLoadBearingScore(f, entrypoints) {
-  let score = 0;
-  if (f.gravity >= 85)
-    score += 2;
-  if (f.heat >= 60)
-    score += 1;
-  if (entrypoints.length >= 2)
-    score += 2;
-  if (f.importedBy.length >= 3)
-    score += 1;
-  if (f.sideEffectProfile.includes("database_write"))
-    score += 3;
-  if (f.sideEffectProfile.includes("booking_mutation"))
-    score += 3;
-  if (f.sideEffectProfile.includes("payment_mutation"))
-    score += 3;
-  if (f.sideEffectProfile.includes("auth_token_mutation"))
-    score += 3;
-  if (f.sideEffectProfile.includes("webhook_delivery"))
-    score += 2;
-  if (f.sideEffectProfile.includes("webhook_ingress"))
-    score += 2;
-  if (f.sideEffectProfile.includes("calendar_mutation"))
-    score += 2;
-  if (f.sideEffectProfile.includes("redirect"))
-    score += 1;
-  if (f.sideEffectProfile.includes("analytics_event"))
-    score += 1;
-  const highImpactDomains = [
-    "booking_creation",
-    "payments",
-    "auth_oauth",
-    "webhooks",
-    "payments_webhooks"
-  ];
-  if (highImpactDomains.includes(f.productDomain))
-    score += 2;
-  const maxSeverity = f.smells.length > 0 ? Math.max(...f.smells.map((s) => s.severity)) : 0;
-  if (maxSeverity === 5)
-    score += 3;
-  return score;
-}
-function computeSeverity(f, entrypoints) {
-  let score = 0;
-  if (f.sideEffectProfile.includes("database_write"))
-    score += 3;
-  if (f.sideEffectProfile.includes("booking_mutation"))
-    score += 4;
-  if (f.sideEffectProfile.includes("payment_mutation"))
-    score += 4;
-  if (f.sideEffectProfile.includes("auth_token_mutation"))
-    score += 4;
-  if (f.sideEffectProfile.includes("webhook_delivery"))
-    score += 3;
-  if (f.sideEffectProfile.includes("webhook_ingress"))
-    score += 3;
-  if (f.sideEffectProfile.includes("calendar_mutation"))
-    score += 3;
-  if (f.productDomain === "booking_creation")
-    score += 3;
-  if (f.productDomain === "payments" || f.productDomain === "payments_webhooks")
-    score += 3;
-  if (f.productDomain === "auth_oauth")
-    score += 3;
-  if (f.productDomain === "webhooks")
-    score += 2;
-  if (f.gravity >= 85)
-    score += 2;
-  if (f.heat >= 70)
-    score += 2;
-  if (f.heatSignals.maxNesting >= 4)
-    score += 1;
-  if (f.heatSignals.longFunctions >= 1)
-    score += 1;
-  if (f.heatSignals.swallowedCatches >= 1)
-    score += 1;
-  if (entrypoints.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 inferRiskTypes(f) {
-  const types = [];
-  const kinds = new Set(f.smells.map((s) => s.kind));
-  if (f.gravitySignals.cyclomatic > 20)
-    types.push("state_machine");
-  if (kinds.has("god-file")) {
-    if (f.frameworkRole === "hook")
-      types.push("god_hook");
-    else
-      types.push("god_component");
-  }
-  if (f.sideEffectProfile.length > 3 && !f.sideEffectProfile.includes("none_detected")) {
-    types.push("side_effect_coupling");
-  }
-  if (f.productDomain === "forms" && f.gravitySignals.fanIn > 5 && f.gravitySignals.publicSurface > 8)
-    types.push("registry_bottleneck");
-  if (f.sideEffectProfile.some((s) => ["booking_mutation", "payment_mutation", "auth_token_mutation"].includes(s)) && f.gravitySignals.cyclomatic > 10)
-    types.push("mutation_orchestration");
-  if (ENTRYPOINT_ROLES.has(f.frameworkRole) && f.sideEffectProfile.includes("database_write"))
-    types.push("route_handler_write_path");
-  if (kinds.has("swallowed-catch"))
-    types.push("error_swallowing");
-  if (f.sideEffectProfile.includes("local_storage") || f.sideEffectProfile.includes("indexed_db"))
-    types.push("storage_persistence_risk");
-  if (types.length === 0)
-    types.push("complexity_hotspot");
-  return types;
-}
-function inferObservableOutputs(f) {
-  const outputs = [];
-  if (f.sideEffectProfile.includes("redirect"))
-    outputs.push("redirect_url");
-  if (ENTRYPOINT_ROLES.has(f.frameworkRole))
-    outputs.push("http_status");
-  if (f.frameworkRole === "app_route_handler" || f.frameworkRole === "pages_api_route") {
-    outputs.push("json_response_shape");
-  }
-  if (f.productDomain === "booking_creation" || f.productDomain === "booking_management") {
-    outputs.push("booking_uid");
-  }
-  if (f.productDomain === "payments" || f.productDomain === "payments_webhooks") {
-    outputs.push("payment_status");
-  }
-  if (f.productDomain === "auth_oauth") {
-    outputs.push("auth_token");
-  }
-  if (f.sideEffectProfile.includes("webhook_delivery") || f.sideEffectProfile.includes("webhook_ingress")) {
-    outputs.push("webhook_payload");
-  }
-  if (f.sideEffectProfile.includes("calendar_mutation")) {
-    outputs.push("calendar_event_id");
-  }
-  if (f.sideEffectProfile.includes("email_send")) {
-    outputs.push("email_payload");
-  }
-  if (f.sideEffectProfile.includes("analytics_event")) {
-    outputs.push("sdk_event_name");
-  }
-  if (f.frameworkRole === "hook" || f.frameworkRole === "store") {
-    outputs.push("ui_state_transition");
-  }
-  return [...new Set(outputs)];
-}
-function inferWriteIntents(f) {
-  const intents = [];
-  if (f.productDomain === "booking_creation") {
-    intents.push("create_booking");
-    if (f.relativePath.includes("reschedule") || f.relativePath.includes("Reschedule"))
-      intents.push("reschedule_booking");
-    if (f.relativePath.includes("recurring") || f.relativePath.includes("Recurring")) {
-      intents.push("create_recurring_booking");
-    }
-  }
-  if (f.productDomain === "booking_management") {
-    intents.push("cancel_booking");
-  }
-  if (f.productDomain === "event_type_configuration") {
-    intents.push("update_event_type");
-  }
-  if (f.productDomain === "availability") {
-    intents.push("update_availability");
-  }
-  if (f.productDomain === "payments") {
-    intents.push("create_payment");
-  }
-  if (f.productDomain === "payments_webhooks") {
-    intents.push("handle_payment_webhook");
-  }
-  if (f.productDomain === "auth_oauth") {
-    intents.push("issue_auth_token");
-    intents.push("refresh_auth_token");
-  }
-  if (f.sideEffectProfile.includes("webhook_delivery")) {
-    intents.push("send_webhook");
-  }
-  if (f.productDomain === "settings") {
-    intents.push("update_user_settings");
-  }
-  if (f.sideEffectProfile.includes("local_storage") || f.sideEffectProfile.includes("indexed_db")) {
-    intents.push("persist_local_state");
-  }
-  return intents.length > 0 ? intents : ["none_detected"];
-}
-function inferPatchRisk(f, score, riskTypes) {
-  if (score >= 12 || f.productDomain === "booking_creation" && riskTypes.includes("mutation_orchestration")) {
-    return {
-      level: "critical",
-      reason: `${f.productDomain} domain with ${riskTypes.join(", ")} \u2014 any patch risks breaking live booking, payment, or auth flows.`
-    };
-  }
-  if (score >= 8 || f.sideEffectProfile.includes("payment_mutation") || f.sideEffectProfile.includes("auth_token_mutation")) {
-    return {
-      level: "high",
-      reason: `${f.productDomain} writes to external state (${f.sideEffectProfile.filter((s) => ["payment_mutation", "auth_token_mutation", "database_write", "webhook_delivery"].includes(s)).join(", ") || "database"}). Changes require integration testing.`
-    };
-  }
-  if (score >= 5 || f.importedBy.length >= 5) {
-    return {
-      level: "medium",
-      reason: `Imported by ${f.importedBy.length} files. Interface changes will cascade.`
-    };
-  }
-  return {
-    level: "low",
-    reason: "Locally contained \u2014 limited blast radius."
-  };
-}
-function inferSafePatchStrategy(f, riskTypes) {
-  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("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 (f.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(f) {
-  const items = [];
-  if (f.sideEffectProfile.includes("payment_mutation"))
-    items.push("payment flow branch");
-  if (f.sideEffectProfile.includes("auth_token_mutation"))
-    items.push("token issuance / refresh branch");
-  if (f.sideEffectProfile.includes("webhook_delivery") || f.sideEffectProfile.includes("webhook_ingress")) {
-    items.push("webhook payload shape");
-  }
-  if (f.sideEffectProfile.includes("redirect"))
-    items.push("redirect URL strings");
-  if (f.sideEffectProfile.includes("analytics_event"))
-    items.push("SDK event names");
-  if (f.sideEffectProfile.includes("booking_mutation")) {
-    items.push("booking success response shape", "recurring booking branch");
-  }
-  if (f.productDomain === "auth_oauth")
-    items.push("OAuth callback URLs", "token scopes");
-  return items;
-}
-function inferTestProbes(f, writeIntents, observableOutputs) {
-  const probes = [];
-  if (writeIntents.includes("create_booking")) {
-    probes.push({
-      name: "standard booking success",
-      scenario: "create a standard booking and assert success redirect and booking uid",
-      expectedObservable: ["booking_uid", "redirect_url", "sdk_event_name"].filter((o) => observableOutputs.includes(o))
-    });
-  }
-  if (writeIntents.includes("reschedule_booking")) {
-    probes.push({
-      name: "reschedule booking",
-      scenario: "reschedule an existing booking and assert reschedule event path",
-      expectedObservable: ["booking_uid", "redirect_url"].filter((o) => observableOutputs.includes(o))
-    });
-  }
-  if (writeIntents.includes("create_recurring_booking")) {
-    probes.push({
-      name: "recurring booking",
-      scenario: "create recurring booking and assert recurring success behavior",
-      expectedObservable: ["booking_uid", "redirect_url"].filter((o) => observableOutputs.includes(o))
-    });
-  }
-  if (writeIntents.includes("handle_payment_webhook")) {
-    probes.push({
-      name: "payment webhook ingestion",
-      scenario: "send a valid payment webhook and assert booking/payment state updated",
-      expectedObservable: ["payment_status", "booking_uid", "http_status"].filter((o) => observableOutputs.includes(o))
-    });
-  }
-  if (writeIntents.includes("issue_auth_token")) {
-    probes.push({
-      name: "token issuance",
-      scenario: "complete OAuth flow and assert access token issued with correct scopes",
-      expectedObservable: ["auth_token", "http_status"].filter((o) => observableOutputs.includes(o))
-    });
-  }
-  return probes;
-}
-function buildRawEvidence(f) {
-  return f.hotSpans.map((span) => ({
-    file: f.relativePath,
-    startLine: span.startLine,
-    endLine: span.endLine,
-    rawSourceExcerpt: span.snippet,
-    evidenceHash: createHash("sha256").update(span.snippet).digest("hex").slice(0, 12)
-  }));
-}
-function deriveConfidence(f) {
-  if (f.gravitySignals.fanIn >= 10 && f.gravity >= 40)
-    return "high";
-  if (f.gravitySignals.fanIn >= 5 || f.gravity >= 25)
-    return "medium";
-  return "low";
-}
-function validateTarget(target) {
-  const warn = (msg) => console.error(`[vibe-splain] WARN ${target.path}: ${msg}`);
-  const err = (msg) => console.error(`[vibe-splain] ERR  ${target.path}: ${msg}`);
-  if (target.severity >= 4 && target.runtimeEntrypoints.length === 0) {
-    warn("high severity target has no runtime entrypoints \u2014 check alias resolution");
-  }
-  if (target.severity === 5 && !target.isLoadBearing) {
-    err("severity 5 target must be load bearing");
-  }
-  if (target.productDomain === "routing_infrastructure" && !target.path.includes("middleware") && !target.path.includes("router") && !target.path.includes("Navigation")) {
-    warn("possible over-classification as routing_infrastructure");
-  }
-  if ((target.path.includes("payment") || target.path.includes("stripe") || target.path.includes("paypal")) && !target.sideEffectProfile.includes("payment_mutation") && !target.sideEffectProfile.includes("webhook_ingress")) {
-    warn("payment file missing payment side effect classification");
-  }
-  if (target.rawEvidence.some((e) => e.rawSourceExcerpt.includes("// ..") || e.rawSourceExcerpt.includes("/* ..."))) {
-    err("raw evidence appears summarized or annotated");
-  }
-}
-async function writeDeltaTargets(projectRoot, store, _entrypoints = /* @__PURE__ */ new Set()) {
-  const targets = Object.values(store.files).filter((f) => f.isRealSource).sort((a, b) => b.gravity - a.gravity).map((f) => {
-    const runtimeEntrypoints = findRuntimeEntrypoints(f.relativePath, store.files);
-    const entrypointTraceStatus = deriveEntrypointTraceStatus(runtimeEntrypoints, f.importsUnresolved);
-    const loadBearingScore = computeLoadBearingScore(f, runtimeEntrypoints);
-    const severity = computeSeverity(f, runtimeEntrypoints);
-    const riskTypes = inferRiskTypes(f);
-    const observableOutputs = inferObservableOutputs(f);
-    const writeIntents = inferWriteIntents(f);
-    const patchRisk = inferPatchRisk(f, loadBearingScore, riskTypes);
-    const rawEvidence = buildRawEvidence(f);
-    const confidence = deriveConfidence(f);
-    const fileHashInput = f.hotSpans.map((h) => h.snippet).join("");
-    const fileHash = createHash("sha256").update(fileHashInput || f.relativePath).digest("hex").slice(0, 12);
-    const target = {
-      path: f.relativePath,
-      frameworkRole: f.frameworkRole,
-      productDomain: f.productDomain,
-      gravity: Math.round(f.gravity),
-      heat: Math.round(f.heat),
-      severity,
-      confidence,
-      isLoadBearing: loadBearingScore >= 5,
-      loadBearingScore,
-      riskTypes,
-      sideEffectProfile: f.sideEffectProfile,
-      blastRadius: f.importedBy,
-      runtimeEntrypoints,
-      entrypointTraceStatus,
-      blockedImports: f.importsUnresolved,
-      observableOutputs,
-      writeIntents,
-      patchRisk,
-      safePatchStrategy: inferSafePatchStrategy(f, riskTypes),
-      doNotTouch: inferDoNotTouch(f),
-      testProbes: inferTestProbes(f, writeIntents, observableOutputs),
-      rawEvidence,
-      analysisAnnotation: `${f.frameworkRole} in ${f.productDomain} domain. fanIn=${f.gravitySignals.fanIn} cyclomatic=${f.gravitySignals.cyclomatic} loc=${f.gravitySignals.loc}`,
-      hashes: {
-        fileHash,
-        evidenceHash: rawEvidence.map((e) => e.evidenceHash).join("-")
-      }
-    };
-    validateTarget(target);
-    return target;
-  });
-  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
-var __dirname = dirname(fileURLToPath(import.meta.url));
-var require2 = createRequire(import.meta.url);
-var parser = null;
-var langCache = /* @__PURE__ */ new Map();
-var EXT_LANG = {
-  ".ts": "typescript",
-  ".tsx": "tsx",
-  ".js": "javascript",
-  ".jsx": "tsx",
-  ".mjs": "javascript",
-  ".cjs": "javascript",
-  ".py": "python",
-  ".go": "go",
-  ".rs": "rust",
-  ".java": "java"
-};
-var LANG_WASM = {
-  typescript: "tree-sitter-typescript.wasm",
-  tsx: "tree-sitter-tsx.wasm",
-  javascript: "tree-sitter-javascript.wasm",
-  python: "tree-sitter-python.wasm",
-  go: "tree-sitter-go.wasm",
-  rust: "tree-sitter-rust.wasm",
-  java: "tree-sitter-java.wasm"
-};
-var SUPPORTED_EXTENSIONS = new Set(Object.keys(EXT_LANG));
-function resolveWasm(file) {
-  try {
-    const wasmsDir = dirname(require2.resolve("tree-sitter-wasms/package.json"));
-    const p = join4(wasmsDir, "out", file);
-    if (existsSync2(p))
-      return p;
-  } catch {
-  }
-  const local = join4(__dirname, "../wasm", file);
-  return existsSync2(local) ? local : null;
-}
-async function getLanguage(lang) {
-  const cached = langCache.get(lang);
-  if (cached)
-    return cached;
-  const wasm = resolveWasm(LANG_WASM[lang]);
-  if (!wasm) {
-    console.error(`[vibe-splain] grammar missing for ${lang} (${LANG_WASM[lang]}); skipping language`);
-    return null;
-  }
-  try {
-    const loaded = await Parser.Language.load(wasm);
-    langCache.set(lang, loaded);
-    return loaded;
-  } catch (err) {
-    console.error(`[vibe-splain] failed to load grammar for ${lang}:`, err instanceof Error ? err.message : err);
-    return null;
-  }
-}
-async function initParser() {
-  if (parser)
-    return parser;
-  await Parser.init();
-  parser = new Parser();
-  const ts = await getLanguage("typescript");
-  if (ts)
-    parser.setLanguage(ts);
-  return parser;
-}
-async function parseAs(lang, source) {
-  const p = await initParser();
-  const language = await getLanguage(lang);
-  if (!language)
-    return null;
-  p.setLanguage(language);
-  try {
-    return p.parse(source);
-  } catch {
-    return null;
+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 EXCLUDE_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  "dist",
-  "build",
-  ".next",
-  "out",
-  ".vibe-splainer",
-  ".git",
-  ".venv",
-  "venv",
-  "env",
-  "__pycache__",
-  ".idea",
-  ".vscode",
-  ".cache",
-  "site-packages",
-  "target",
-  ".tox",
-  ".mypy_cache",
-  ".pytest_cache"
-]);
-var EXCLUDE_FILE_PATTERNS = [/\.lock$/, /\.min\.[a-z]+$/, /\.d\.ts$/];
-var DEMOTE_SEGMENTS = /* @__PURE__ */ new Set([
-  "docs",
-  "doc",
-  "examples",
-  "example",
-  "samples",
-  "sample",
-  "mockup",
-  "mockups",
-  "fixtures",
-  "fixture",
-  "__generated__",
-  "__mocks__",
-  "playwright",
-  "e2e",
-  "__tests__",
-  "cypress",
-  "storybook",
-  "stories",
-  ".storybook"
-]);
-var VENDOR_SEGMENTS = /* @__PURE__ */ new Set([
-  "node_modules",
-  "vendor",
-  "vendored",
-  "site-packages",
-  "third_party",
-  "third-party"
-]);
 var PILLAR_KEYWORDS = {
   "Auth": [
     "passport",
@@ -769,29 +472,9 @@ 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,
@@ -817,264 +500,711 @@ var MEANINGLESS_SEGMENTS = /* @__PURE__ */ new Set([
   "pkg",
   "packages"
 ]);
-function matchPillarByImports(importSpecs) {
-  const scores = /* @__PURE__ */ new Map();
-  for (const spec of importSpecs) {
-    for (const [pillar, keywords] of Object.entries(PILLAR_KEYWORDS)) {
-      if (keywords.some((kw) => spec === kw || spec.startsWith(kw + "/"))) {
-        scores.set(pillar, (scores.get(pillar) || 0) + 1);
-      }
+function matchPillarByImports(importSpecs) {
+  const scores = /* @__PURE__ */ new Map();
+  for (const spec of importSpecs) {
+    for (const [pillar, keywords] of Object.entries(PILLAR_KEYWORDS)) {
+      if (keywords.some((kw) => spec === kw || spec.startsWith(kw + "/"))) {
+        scores.set(pillar, (scores.get(pillar) || 0) + 1);
+      }
+    }
+  }
+  if (scores.size === 0)
+    return null;
+  return [...scores.entries()].sort((a, b) => b[1] - a[1])[0][0];
+}
+function matchPillarByPath(relPath) {
+  for (const [pillar, pattern] of Object.entries(PILLAR_PATH_PATTERNS)) {
+    if (pattern.test(relPath))
+      return pillar;
+  }
+  return null;
+}
+function extractImports(source, lang) {
+  const specs = [];
+  if (lang === "python") {
+    const re2 = /^[ \t]*(?:from[ \t]+([.\w]+)[ \t]+import|import[ \t]+([.\w][.\w ,]*))/gm;
+    let m2;
+    while ((m2 = re2.exec(source)) !== null) {
+      if (m2[1]) {
+        specs.push(m2[1]);
+      } else if (m2[2]) {
+        for (const part of m2[2].split(",")) {
+          const name = part.trim().split(/\s+as\s+/)[0].trim();
+          if (name)
+            specs.push(name);
+        }
+      }
+    }
+    return specs;
+  }
+  if (lang === "go") {
+    const re2 = /"([^"]+)"/g;
+    const importBlock = source.match(/import\s*\(([\s\S]*?)\)/g) || [];
+    for (const block of importBlock) {
+      let m3;
+      while ((m3 = re2.exec(block)) !== null)
+        specs.push(m3[1]);
+    }
+    const single = /import\s+(?:\w+\s+)?"([^"]+)"/g;
+    let m2;
+    while ((m2 = single.exec(source)) !== null)
+      specs.push(m2[1]);
+    return specs;
+  }
+  if (lang === "rust") {
+    const re2 = /\b(?:use|mod)\s+([\w:]+)/g;
+    let m2;
+    while ((m2 = re2.exec(source)) !== null)
+      specs.push(m2[1]);
+    return specs;
+  }
+  if (lang === "java") {
+    const re2 = /import\s+(?:static\s+)?([\w.]+)/g;
+    let m2;
+    while ((m2 = re2.exec(source)) !== null)
+      specs.push(m2[1]);
+    return specs;
+  }
+  const re = /(?:import|export)\s[^;]*?from\s*['"]([^'"]+)['"]|(?:import|require)\s*\(\s*['"]([^'"]+)['"]/g;
+  let m;
+  while ((m = re.exec(source)) !== null)
+    specs.push(m[1] || m[2]);
+  return specs;
+}
+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);
+    }
+  }
+  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);
+  }
+  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);
+    }
+  }
+  return { stack: [...stack], entrypoints };
+}
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "function",
+  "function_expression",
+  "arrow_function",
+  "method_definition",
+  "function_definition",
+  "method_declaration",
+  "func_literal",
+  "function_item",
+  "closure_expression",
+  "constructor_declaration",
+  "generator_function_declaration",
+  "generator_function"
+]);
+var NESTING_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "function",
+  "arrow_function",
+  "function_expression",
+  "method_definition",
+  "function_definition",
+  "method_declaration",
+  "function_item",
+  "class_declaration",
+  "class",
+  "class_definition",
+  "class_item",
+  "if_statement",
+  "if_expression",
+  "for_statement",
+  "for_in_statement",
+  "for_expression",
+  "enhanced_for_statement",
+  "while_statement",
+  "while_expression",
+  "do_statement",
+  "switch_statement",
+  "match_expression",
+  "match_arm",
+  "try_statement",
+  "catch_clause",
+  "except_clause",
+  "loop_expression",
+  "block"
+]);
+var DECISION_TYPES = /* @__PURE__ */ new Set([
+  "if_statement",
+  "if_expression",
+  "elif_clause",
+  "for_statement",
+  "for_in_statement",
+  "for_expression",
+  "enhanced_for_statement",
+  "while_statement",
+  "while_expression",
+  "do_statement",
+  "loop_expression",
+  "case",
+  "switch_case",
+  "case_clause",
+  "match_arm",
+  "catch_clause",
+  "except_clause",
+  "communication_case",
+  "conditional_expression",
+  "ternary_expression"
+]);
+var CATCH_TYPES = /* @__PURE__ */ new Set(["catch_clause", "except_clause"]);
+var LONG_FN_LOC = 60;
+var DEEP_NESTING = 5;
+var GOD_FILE_LOC = 400;
+var GOD_FILE_EXPORTS = 8;
+function nodeLOC(node) {
+  return node.endPosition.row - node.startPosition.row + 1;
+}
+function countDecisions(node) {
+  let count = 0;
+  const walk = (n) => {
+    if (DECISION_TYPES.has(n.type))
+      count++;
+    if (n.type === "binary_expression") {
+      const op = n.children.find((c) => c.type === "&&" || c.type === "||");
+      if (op)
+        count++;
     }
+    if (n.type === "boolean_operator")
+      count++;
+    for (const c of n.children)
+      walk(c);
+  };
+  walk(node);
+  return count;
+}
+function computeNesting(node, depth) {
+  let maxDepth = depth;
+  for (const child of node.children) {
+    const nextDepth = NESTING_TYPES.has(child.type) ? depth + 1 : depth;
+    maxDepth = Math.max(maxDepth, computeNesting(child, nextDepth));
   }
-  if (scores.size === 0)
-    return null;
-  return [...scores.entries()].sort((a, b) => b[1] - a[1])[0][0];
+  return maxDepth;
 }
-function matchPillarByPath(relPath) {
-  for (const [pillar, pattern] of Object.entries(PILLAR_PATH_PATTERNS)) {
-    if (pattern.test(relPath))
-      return pillar;
+function firstLine(s) {
+  return s.split("\n")[0];
+}
+function stripLeadingComments(snippet) {
+  const lines = snippet.split("\n");
+  let i = 0;
+  let inBlock = false;
+  while (i < lines.length) {
+    const t = lines[i].trim();
+    if (inBlock) {
+      if (t.includes("*/"))
+        inBlock = false;
+      i++;
+      continue;
+    }
+    if (t === "") {
+      i++;
+      continue;
+    }
+    if (t.startsWith("//") || t.startsWith("#")) {
+      i++;
+      continue;
+    }
+    if (t.startsWith("/*")) {
+      inBlock = !t.includes("*/");
+      i++;
+      continue;
+    }
+    if (t.startsWith('"""') || t.startsWith("'''")) {
+      const q = t.slice(0, 3);
+      if (t.length > 3 && t.endsWith(q)) {
+        i++;
+        continue;
+      }
+      i++;
+      while (i < lines.length && !lines[i].includes(q))
+        i++;
+      i++;
+      continue;
+    }
+    break;
   }
-  return null;
+  return lines.slice(i).join("\n");
 }
-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";
+var TODO_RE = /\b(TODO|FIXME|HACK|XXX|KLUDGE)\b|@deprecated/;
+var SUPPRESS_RE = /@ts-ignore|@ts-nocheck|eslint-disable|:\s*any\b|#\s*type:\s*ignore|type:\s*ignore|#\s*nosec/;
+function collectFunctionNodes(root) {
+  const out = [];
+  const walk = (n) => {
+    if (FUNCTION_TYPES.has(n.type))
+      out.push(n);
+    for (const c of n.children)
+      walk(c);
+  };
+  walk(root);
+  return out;
 }
-function inferProductDomain(relPath, importSpecs) {
-  const p = relPath.toLowerCase().replace(/\\/g, "/");
-  if (/\.test\.|\.spec\.|__tests__|\/e2e\/|\/playwright\/|\/cypress\//.test(p)) {
-    return "test_infrastructure";
+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;
+  return meaningful.every((l) => /^(console\.(log|error|warn|info)|print|println!?|System\.out|logger?\.)/.test(l) || l === "pass" || l === "{" || l === "});" || l === ")" || l === "`");
+}
+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 (/\.generated\.|__generated__|\.prisma\//.test(p)) {
-    return "generated_noise";
+  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;
   }
-  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";
+  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 inferSideEffectProfile(source, importSpecs) {
-  const effects = /* @__PURE__ */ new Set();
-  if (/router\.(push|replace|back)\(|redirect\(|notFound\(|permanentRedirect\(/.test(source)) {
-    effects.add("redirect");
+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" });
+    }
   }
-  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");
+  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);
+  };
+  magicWalk(root);
+  if (magicNumbers > 6) {
+    smells.push({ kind: "magic-number", line: 1, endLine: 1, text: `${magicNumbers} unexplained numeric literals`, severity: 2, note: "many magic numbers \u2014 extract named constants" });
   }
-  if (/prisma\s*[.?]\s*\w+\s*[.?]\s*(findMany|findUnique|findFirst|findFirstOrThrow|findUniqueOrThrow|count|aggregate|groupBy)\b/.test(source)) {
-    effects.add("database_read");
+  let swallowedCatches = 0;
+  const catchWalk = (n) => {
+    if (CATCH_TYPES.has(n.type) && catchIsSwallowed(n)) {
+      swallowedCatches++;
+      smells.push({
+        kind: "swallowed-catch",
+        line: n.startPosition.row + 1,
+        endLine: n.endPosition.row + 1,
+        text: firstLine(n.text).trim().slice(0, 200),
+        severity: 4,
+        note: "catch block swallows error silently"
+      });
+    }
+    for (const c of n.children)
+      catchWalk(c);
+  };
+  catchWalk(root);
+  const fnNodes = collectFunctionNodes(root);
+  let longFunctions = 0;
+  const scored = [];
+  for (const fn of fnNodes) {
+    const bodyLOC = nodeLOC(fn);
+    const decisions = countDecisions(fn);
+    scored.push({ node: fn, decisions, bodyLOC, score: decisions + bodyLOC });
+    if (bodyLOC > LONG_FN_LOC) {
+      longFunctions++;
+      smells.push({
+        kind: "long-function",
+        line: fn.startPosition.row + 1,
+        endLine: fn.endPosition.row + 1,
+        text: firstLine(fn.text).trim().slice(0, 200),
+        severity: 3,
+        note: `function body is ${bodyLOC} lines`
+      });
+    }
   }
-  if (/createBooking|handleNewBooking|cancelBooking|rescheduleBooking|handleBooking|createRecurring/.test(source)) {
-    effects.add("booking_mutation");
+  if (maxNesting > DEEP_NESTING) {
+    smells.push({ kind: "deep-nesting", line: 1, endLine: 1, text: `nesting depth ${maxNesting}`, severity: 3, note: `control flow nested ${maxNesting} levels deep` });
   }
-  if (importSpecs.some((s) => /stripe|paypal|btcpay|alby/.test(s.toLowerCase())) || /stripe\.|paymentIntent|createPaymentIntent|confirmPayment|createCharge/.test(source))
-    effects.add("payment_mutation");
-  if (/signIn\b|signOut\b|createSession|destroySession|issueToken|refreshToken|getToken/.test(source)) {
-    effects.add("auth_token_mutation");
+  const exported = collectExports(root, lang);
+  const publicSurface = exported.length;
+  const signature = exported.map((e) => e.text).join("\n").slice(0, 4e3);
+  if (loc > GOD_FILE_LOC && publicSurface > GOD_FILE_EXPORTS) {
+    smells.push({
+      kind: "god-file",
+      line: 1,
+      endLine: 1,
+      text: `${loc} LOC, ${publicSurface} exports`,
+      severity: 4,
+      note: `god-file: ${loc} lines exporting ${publicSurface} symbols`
+    });
   }
-  if (/triggerWebhook|sendWebhook|webhook\.send\b/.test(source))
-    effects.add("webhook_delivery");
-  if (/webhookSecret|stripe\.webhooks\.constructEvent|validateWebhook|verifyWebhook/.test(source)) {
-    effects.add("webhook_ingress");
+  scored.sort((a, b) => b.score - a.score);
+  const hotSpans = scored.slice(0, 3).filter((s) => s.bodyLOC >= 4).map((s) => {
+    const rawExcerpt = source.split("\n").slice(s.node.startPosition.row, s.node.endPosition.row + 1).join("\n");
+    const snippet = stripLeadingComments(rawExcerpt).slice(0, 2e3);
+    return {
+      startLine: s.node.startPosition.row + 1,
+      endLine: s.node.endPosition.row + 1,
+      rawExcerpt,
+      snippet,
+      reason: `high complexity: ${s.decisions} decision branches across ${s.bodyLOC} lines`
+    };
+  });
+  return {
+    language: lang,
+    loc,
+    cyclomatic,
+    maxNesting,
+    publicSurface,
+    exportedNames: exported.map((e) => e.name),
+    signature,
+    longFunctions,
+    magicNumbers,
+    swallowedCatches,
+    smells,
+    hotSpans
+  };
+}
+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);
   }
-  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");
+  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
+    });
   }
-  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");
+  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
+  };
+  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;
   }
-  if (effects.size === 0)
-    effects.add("none_detected");
-  return [...effects];
 }
-async function collectFiles(dir, projectRoot, acc) {
-  let entries;
+async function extractTsConfigPaths(tsconfigPath, projectRoot, depth = 0) {
+  if (depth > 3 || !existsSync3(tsconfigPath))
+    return {};
+  let raw;
   try {
-    entries = await readdir(dir, { withFileTypes: true });
+    raw = await readFile5(tsconfigPath, "utf8");
   } catch {
-    return;
+    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;
   }
-  for (const entry of entries) {
-    if (entry.name.startsWith(".") && entry.name !== ".") {
-      if (entry.isDirectory())
-        continue;
-    }
-    if (EXCLUDE_DIRS.has(entry.name))
+  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 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))
+    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;
-      if (EXCLUDE_FILE_PATTERNS.some((p) => p.test(entry.name)))
+      try {
+        const wsPkg = JSON.parse(await readFile5(wsPkgPath, "utf8"));
+        if (typeof wsPkg.name === "string") {
+          packages[wsPkg.name] = relative2(projectRoot, join5(absPrefix, entry));
+        }
+      } catch {
         continue;
-      acc.push(fullPath);
+      }
     }
   }
+  return packages;
 }
-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") {
-    const re2 = /^[ \t]*(?:from[ \t]+([.\w]+)[ \t]+import|import[ \t]+([.\w][.\w ,]*))/gm;
-    let m2;
-    while ((m2 = re2.exec(source)) !== null) {
-      if (m2[1]) {
-        specs.push(m2[1]);
-      } else if (m2[2]) {
-        for (const part of m2[2].split(",")) {
-          const name = part.trim().split(/\s+as\s+/)[0].trim();
-          if (name)
-            specs.push(name);
-        }
+async function discoverAppTsConfigPaths(projectRoot) {
+  const result = {};
+  const scanDirs = ["apps", "packages"];
+  for (const scanDir of scanDirs) {
+    const absDir = join5(projectRoot, scanDir);
+    if (!existsSync3(absDir))
+      continue;
+    const { readdir: readdir2 } = await import("fs/promises");
+    try {
+      const entries = await readdir2(absDir, { withFileTypes: true });
+      for (const entry of entries.filter((e) => e.isDirectory())) {
+        const tsconfig = join5(absDir, entry.name, "tsconfig.json");
+        const paths = await extractTsConfigPaths(tsconfig, projectRoot);
+        Object.assign(result, paths);
       }
+    } catch {
+      continue;
     }
-    return specs;
-  }
-  if (lang === "go") {
-    const re2 = /"([^"]+)"/g;
-    const importBlock = source.match(/import\s*\(([\s\S]*?)\)/g) || [];
-    for (const block of importBlock) {
-      let m3;
-      while ((m3 = re2.exec(block)) !== null)
-        specs.push(m3[1]);
-    }
-    const single = /import\s+(?:\w+\s+)?"([^"]+)"/g;
-    let m2;
-    while ((m2 = single.exec(source)) !== null)
-      specs.push(m2[1]);
-    return specs;
-  }
-  if (lang === "rust") {
-    const re2 = /\b(?:use|mod)\s+([\w:]+)/g;
-    let m2;
-    while ((m2 = re2.exec(source)) !== null)
-      specs.push(m2[1]);
-    return specs;
-  }
-  if (lang === "java") {
-    const re2 = /import\s+(?:static\s+)?([\w.]+)/g;
-    let m2;
-    while ((m2 = re2.exec(source)) !== null)
-      specs.push(m2[1]);
-    return specs;
-  }
-  const re = /(?:import|export)\s[^;]*?from\s*['"]([^'"]+)['"]|(?:import|require)\s*\(\s*['"]([^'"]+)['"]/g;
-  let m;
-  while ((m = re.exec(source)) !== null) {
-    specs.push(m[1] || m[2]);
   }
-  return specs;
+  return result;
 }
-var MONOREPO_ALIASES = [
+var CONVENTIONAL_ALIASES = [
   { prefix: "~/", replacement: "" },
   { prefix: "@components/", replacement: "components/" },
   { prefix: "@lib/", replacement: "lib/" },
@@ -1087,43 +1217,28 @@ var MONOREPO_ALIASES = [
   { prefix: "@calcom/ui/", replacement: "../packages/ui/" },
   { prefix: "@calcom/emails/", replacement: "../packages/emails/" }
 ];
-function resolveAlias(spec) {
-  for (const { prefix, replacement } of MONOREPO_ALIASES) {
-    if (spec.startsWith(prefix)) {
-      return replacement + spec.slice(prefix.length);
+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;
     }
   }
-  return null;
+  return { resolvedAliases, workspacePackages };
 }
 var JS_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-function resolveImport(spec, fromAbs, lang, projectRoot, fileSet, basenameIndex) {
-  if (lang === "python") {
-    return { resolved: resolvePython(spec, fromAbs, projectRoot, fileSet), isAlias: false };
-  }
-  if (lang === "typescript" || lang === "tsx" || lang === "javascript") {
-    if (spec.startsWith(".")) {
-      const base = join4(dirname(fromAbs), spec);
-      return { resolved: tryJsCandidates(base, projectRoot, fileSet), isAlias: false };
-    }
-    const aliasResolved = resolveAlias(spec);
-    if (aliasResolved !== null) {
-      const base = join4(projectRoot, aliasResolved);
-      const resolved = tryJsCandidates(base, projectRoot, fileSet);
-      return { resolved, isAlias: true };
-    }
-    return { resolved: null, isAlias: false };
-  }
-  return { resolved: resolveGeneric(spec, projectRoot, fileSet, basenameIndex), isAlias: false };
-}
 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(join4(base, "index" + ext));
-  candidates.unshift(base);
+    candidates.push(join5(base, "index" + ext));
   for (const c of candidates) {
-    const rel = relative(projectRoot, c);
+    const rel = relative2(projectRoot, c);
     if (fileSet.has(rel))
       return rel;
   }
@@ -1133,19 +1248,17 @@ function resolvePython(spec, fromAbs, projectRoot, fileSet) {
   let modulePath;
   if (spec.startsWith(".")) {
     const dots = spec.match(/^\.+/)[0].length;
-    let dir = dirname(fromAbs);
+    let dir = dirname2(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;
+      dir = dirname2(dir);
+    const rest = spec.slice(dots).replace(/\./g, sep2);
+    modulePath = rest ? join5(dir, rest) : dir;
   } else {
-    modulePath = join4(projectRoot, spec.replace(/\./g, sep));
+    modulePath = join5(projectRoot, spec.replace(/\./g, sep2));
   }
-  const candidates = [modulePath + ".py", join4(modulePath, "__init__.py")];
-  for (const c of candidates) {
-    const rel = relative(projectRoot, c);
-    if (fileSet.has(rel))
-      return rel;
+  for (const c of [modulePath + ".py", join5(modulePath, "__init__.py")]) {
+    if (fileSet.has(relative2(projectRoot, c)))
+      return relative2(projectRoot, c);
   }
   return null;
 }
@@ -1156,8 +1269,8 @@ function resolveGeneric(spec, projectRoot, fileSet, basenameIndex) {
     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)))
+    const noExt = rel.slice(0, rel.length - extname2(rel).length);
+    if (noExt.endsWith(parts.join(sep2)))
       return rel;
   }
   const byBase = basenameIndex.get(last);
@@ -1165,942 +1278,1365 @@ function resolveGeneric(spec, projectRoot, fileSet, basenameIndex) {
     return byBase[0];
   return null;
 }
-var FUNCTION_TYPES = /* @__PURE__ */ new Set([
-  "function_declaration",
-  "function",
-  "function_expression",
-  "arrow_function",
-  "method_definition",
-  "function_definition",
-  "method_declaration",
-  "func_literal",
-  "function_item",
-  "closure_expression",
-  "constructor_declaration",
-  "generator_function_declaration",
-  "generator_function"
-]);
-var NESTING_TYPES = /* @__PURE__ */ new Set([
-  "function_declaration",
-  "function",
-  "arrow_function",
-  "function_expression",
-  "method_definition",
-  "function_definition",
-  "method_declaration",
-  "function_item",
-  "class_declaration",
-  "class",
-  "class_definition",
-  "class_item",
-  "if_statement",
-  "if_expression",
-  "for_statement",
-  "for_in_statement",
-  "for_expression",
-  "enhanced_for_statement",
-  "while_statement",
-  "while_expression",
-  "do_statement",
-  "switch_statement",
-  "match_expression",
-  "match_arm",
-  "try_statement",
-  "catch_clause",
-  "except_clause",
-  "loop_expression",
-  "block"
-]);
-var DECISION_TYPES = /* @__PURE__ */ new Set([
-  "if_statement",
-  "if_expression",
-  "elif_clause",
-  "for_statement",
-  "for_in_statement",
-  "for_expression",
-  "enhanced_for_statement",
-  "while_statement",
-  "while_expression",
-  "do_statement",
-  "loop_expression",
-  "case",
-  "switch_case",
-  "case_clause",
-  "match_arm",
-  "catch_clause",
-  "except_clause",
-  "communication_case",
-  "conditional_expression",
-  "ternary_expression"
-]);
-var CATCH_TYPES = /* @__PURE__ */ new Set(["catch_clause", "except_clause"]);
-var LONG_FN_LOC = 60;
-var DEEP_NESTING = 5;
-var GOD_FILE_LOC = 400;
-var GOD_FILE_EXPORTS = 8;
-function nodeLOC(node) {
-  return node.endPosition.row - node.startPosition.row + 1;
+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 [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 };
+  }
+  return { resolved: resolveGeneric(spec, projectRoot, fileSet, basenameIndex), isAlias: false };
 }
-function countDecisions(node) {
-  let count = 0;
-  const walk = (n) => {
-    if (DECISION_TYPES.has(n.type))
-      count++;
-    if (n.type === "binary_expression") {
-      const op = n.children.find((c) => c.type === "&&" || c.type === "||");
-      if (op)
-        count++;
+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;
+        }
+      }
     }
-    if (n.type === "boolean_operator")
-      count++;
-    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
+  };
+  await writeFile5(join5(dir, "stage-04-aliases.json"), JSON.stringify(stage04, null, 2), "utf8");
+  return {
+    aliasMap,
+    importedBy,
+    importsResolved,
+    importsUnresolved,
+    fanOut,
+    graph,
+    unresolvedImports,
+    resolutionFailuresByFile,
+    resolutionFailureReasons
   };
-  walk(node);
-  return count;
 }
-function computeNesting(node, depth) {
-  let maxDepth = depth;
-  for (const child of node.children) {
-    const nextDepth = NESTING_TYPES.has(child.type) ? depth + 1 : depth;
-    maxDepth = Math.max(maxDepth, computeNesting(child, nextDepth));
+
+// ../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");
   }
-  return maxDepth;
+  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 firstLine(s) {
-  return s.split("\n")[0];
+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"];
 }
-function stripLeadingComments(snippet) {
-  const lines = snippet.split("\n");
-  let i = 0;
-  let inBlock = false;
-  while (i < lines.length) {
-    const t = lines[i].trim();
-    if (inBlock) {
-      if (t.includes("*/"))
-        inBlock = false;
-      i++;
+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 (t === "") {
-      i++;
+    if (current.depth >= maxDepth)
       continue;
-    }
-    if (t.startsWith("//") || t.startsWith("#")) {
-      i++;
+    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 });
     }
-    if (t.startsWith("/*")) {
-      inBlock = !t.includes("*/");
-      i++;
-      continue;
+  }
+  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;
+  const rank = /* @__PURE__ */ new Map();
+  if (n === 0)
+    return rank;
+  for (const node of nodes)
+    rank.set(node, 1 / n);
+  const inEdges = /* @__PURE__ */ new Map();
+  for (const node of nodes)
+    inEdges.set(node, []);
+  const outCount = /* @__PURE__ */ new Map();
+  for (const [from, tos] of outEdges) {
+    const valid = [...tos].filter((t) => rank.has(t));
+    outCount.set(from, valid.length);
+    for (const to of valid)
+      inEdges.get(to).push(from);
+  }
+  for (let it = 0; it < iters; it++) {
+    const next = /* @__PURE__ */ new Map();
+    let dangling = 0;
+    for (const node of nodes) {
+      if ((outCount.get(node) || 0) === 0)
+        dangling += rank.get(node);
     }
-    if (t.startsWith('"""') || t.startsWith("'''")) {
-      const q = t.slice(0, 3);
-      if (t.length > 3 && t.endsWith(q)) {
-        i++;
+    for (const node of nodes) {
+      let sum = 0;
+      for (const from of inEdges.get(node)) {
+        sum += rank.get(from) / (outCount.get(from) || 1);
+      }
+      next.set(node, (1 - damping) / n + damping * (sum + dangling / n));
+    }
+    for (const node of nodes)
+      rank.set(node, next.get(node));
+  }
+  let max = 0;
+  for (const v of rank.values())
+    max = Math.max(max, v);
+  if (max > 0)
+    for (const node of nodes)
+      rank.set(node, rank.get(node) / max);
+  return rank;
+}
+function detectCommunities(nodes, adjacency) {
+  const label = /* @__PURE__ */ new Map();
+  nodes.forEach((node, i) => label.set(node, i));
+  for (let pass = 0; pass < 10; pass++) {
+    let changed = false;
+    for (const node of nodes) {
+      const neighbors = adjacency.get(node);
+      if (!neighbors || neighbors.size === 0)
         continue;
+      const counts = /* @__PURE__ */ new Map();
+      for (const [nb, weight] of neighbors) {
+        const l = label.get(nb);
+        counts.set(l, (counts.get(l) || 0) + weight);
+      }
+      let best = label.get(node), bestCount = -1;
+      for (const [l, c] of counts) {
+        if (c > bestCount || c === bestCount && l < best) {
+          best = l;
+          bestCount = c;
+        }
+      }
+      if (best !== label.get(node)) {
+        label.set(node, best);
+        changed = true;
       }
-      i++;
-      while (i < lines.length && !lines[i].includes(q))
-        i++;
-      i++;
-      continue;
     }
-    break;
+    if (!changed)
+      break;
   }
-  return lines.slice(i).join("\n");
+  return label;
 }
-var TODO_RE = /\b(TODO|FIXME|HACK|XXX|KLUDGE)\b|@deprecated/;
-var SUPPRESS_RE = /@ts-ignore|@ts-nocheck|eslint-disable|:\s*any\b|#\s*type:\s*ignore|type:\s*ignore|#\s*nosec/;
-function collectFunctionNodes(root) {
-  const out = [];
-  const walk = (n) => {
-    if (FUNCTION_TYPES.has(n.type))
-      out.push(n);
-    for (const c of n.children)
-      walk(c);
-  };
-  walk(root);
-  return out;
+function titleCase(s) {
+  return s.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
-function catchIsSwallowed(node, _lang) {
-  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;
+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 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" });
+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 (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" });
+  }
+  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];
+  }
+  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]);
   }
-  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++;
-      }
+  const topFile = basename2(files[0].rel, extname3(files[0].rel));
+  return titleCase(topFile);
+}
+function dirname_simple(p) {
+  const idx = p.lastIndexOf(sep3);
+  if (idx < 0)
+    return ".";
+  return p.slice(0, idx);
+}
+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);
     }
-    for (const c of n.children)
-      magicWalk(c);
-  };
-  magicWalk(root);
-  if (magicNumbers > 6) {
-    smells.push({ kind: "magic-number", line: 1, endLine: 1, text: `${magicNumbers} unexplained numeric literals`, severity: 2, note: "many magic numbers \u2014 extract named constants" });
   }
-  let swallowedCatches = 0;
-  const catchWalk = (n) => {
-    if (CATCH_TYPES.has(n.type) && catchIsSwallowed(n, lang)) {
-      swallowedCatches++;
-      smells.push({
-        kind: "swallowed-catch",
-        line: n.startPosition.row + 1,
-        endLine: n.endPosition.row + 1,
-        text: firstLine(n.text).trim().slice(0, 200),
-        severity: 4,
-        note: "catch block swallows error silently"
-      });
+  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);
     }
-    for (const c of n.children)
-      catchWalk(c);
-  };
-  catchWalk(root);
-  const fnNodes = collectFunctionNodes(root);
-  let longFunctions = 0;
-  const scored = [];
-  for (const fn of fnNodes) {
-    const bodyLOC = nodeLOC(fn);
-    const decisions = countDecisions(fn);
-    scored.push({ node: fn, decisions, bodyLOC, score: decisions + bodyLOC });
-    if (bodyLOC > LONG_FN_LOC) {
-      longFunctions++;
-      smells.push({
-        kind: "long-function",
-        line: fn.startPosition.row + 1,
-        endLine: fn.endPosition.row + 1,
-        text: firstLine(fn.text).trim().slice(0, 200),
-        severity: 3,
-        note: `function body is ${bodyLOC} lines`
-      });
+    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)
+        });
+      }
     }
   }
-  if (maxNesting > DEEP_NESTING) {
-    smells.push({ kind: "deep-nesting", line: 1, endLine: 1, text: `nesting depth ${maxNesting}`, severity: 3, note: `control flow nested ${maxNesting} levels deep` });
+  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) });
   }
-  const exported = collectExports(root, lang);
-  const publicSurface = exported.length;
-  const signature = exported.map((e) => e.text).join("\n").slice(0, 4e3);
-  if (loc > GOD_FILE_LOC && publicSurface > GOD_FILE_EXPORTS) {
-    smells.push({
-      kind: "god-file",
-      line: 1,
-      endLine: 1,
-      text: `${loc} LOC, ${publicSurface} exports`,
-      severity: 4,
-      note: `god-file: ${loc} lines exporting ${publicSurface} symbols`
-    });
+  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);
+    }
   }
-  scored.sort((a, b) => b.score - a.score);
-  const hotSpans = scored.slice(0, 3).filter((s) => s.bodyLOC >= 4).map((s) => {
-    const raw = source.split("\n").slice(s.node.startPosition.row, s.node.endPosition.row + 1).join("\n");
-    const snippet = stripLeadingComments(raw).slice(0, 2e3);
-    return {
-      startLine: s.node.startPosition.row + 1,
-      endLine: s.node.endPosition.row + 1,
-      snippet,
-      reason: `high complexity: ${s.decisions} decision branches across ${s.bodyLOC} lines`
-    };
-  });
-  return {
-    language: lang,
-    loc,
-    cyclomatic,
-    maxNesting,
-    publicSurface,
-    exportedNames: exported.map((e) => e.name),
-    signature,
-    longFunctions,
-    magicNumbers,
-    swallowedCatches,
-    smells,
-    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) });
-  };
-  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);
-      }
+  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) {
+    if (w.pathDemote) {
+      isRealSource.set(w.rel, false);
+      demoteReason.set(w.rel, w.pathDemote);
+    } else {
+      isRealSource.set(w.rel, true);
+      demoteReason.set(w.rel, null);
     }
-    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;
+  for (const w of work) {
+    if (!isRealSource.get(w.rel))
+      continue;
+    if (entrypoints.has(w.rel))
+      continue;
+    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");
+    }
   }
-  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;
+  const realNodes = work.filter((w) => isRealSource.get(w.rel)).map((w) => w.rel);
+  const realSet = new Set(realNodes);
+  const outEdges = /* @__PURE__ */ new Map();
+  const undirected = /* @__PURE__ */ new Map();
+  for (const node of realNodes) {
+    outEdges.set(node, /* @__PURE__ */ new Set());
+    undirected.set(node, /* @__PURE__ */ new Map());
   }
-  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);
+  for (const w of work) {
+    if (!realSet.has(w.rel))
+      continue;
+    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(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);
+    }
+  }
+  const ranks = pageRank(realNodes, outEdges);
+  const communities = detectCommunities(realNodes, undirected);
+  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 centrality = real ? ranks.get(w.rel) || 0 : 0;
+    const gs = {
+      fanIn,
+      fanOut: fanOut.get(w.rel) || 0,
+      centrality,
+      cyclomatic: w.ast.cyclomatic,
+      publicSurface: w.ast.publicSurface,
+      loc: w.ast.loc
     };
-    walk2(root);
-    return out;
+    const depthRatio = (w.ast.cyclomatic + w.ast.maxNesting * 2) / Math.max(1, w.ast.publicSurface);
+    const depthFactor = Math.min(1, Math.log2(depthRatio + 1) / 3);
+    const adjustedCentrality = centrality * (0.3 + 0.7 * depthFactor);
+    let gravityRaw = adjustedCentrality * 50 + Math.log2(fanIn + 1) * 6 + Math.log2(w.ast.cyclomatic + 1) * 7 + Math.log2(w.ast.publicSurface + 1) * 2 + (w.ast.maxNesting >= 4 ? 5 : 0);
+    if (!real)
+      gravityRaw *= 0.2;
+    const gravity = Math.max(0, Math.min(100, gravityRaw));
+    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);
   }
-  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);
+  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);
       }
-      if (n.text.includes("export default"))
-        push("default", n);
     }
-    for (const c of n.children)
-      walk(c);
+    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,
+      maxNesting: w.ast.maxNesting,
+      longFunctions: w.ast.longFunctions,
+      magicNumbers: w.ast.magicNumbers
+    };
+    const keywordPillar = matchPillarByImports(w.importSpecs);
+    const pathPillar = matchPillarByPath(w.rel);
+    const pillarHint = real ? keywordPillar || pathPillar || `community-${communities.get(w.rel)}` : null;
+    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: gs,
+      heatSignals: hs,
+      smells: w.ast.smells,
+      pillarHint,
+      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 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: inv.stack,
+    entrypoints: [...entrypoints],
+    pillars,
+    fileCount: work.length,
+    realSourceCount: realClassified.length,
+    topGravity: realClassified.slice(0, 12).map((f) => f.rel),
+    topHeat: wildCandidates.slice(0, 12).map((f) => f.rel),
+    brief: null
   };
-  walk(root);
-  return out;
+  return { projectRoot, classified, stack: inv.stack, entrypoints, map, communities };
 }
-function pageRank(nodes, outEdges, damping = 0.85, iters = 20) {
-  const n = nodes.length;
-  const rank = /* @__PURE__ */ new Map();
-  if (n === 0)
-    return rank;
-  for (const node of nodes)
-    rank.set(node, 1 / n);
-  const inEdges = /* @__PURE__ */ new Map();
-  for (const node of nodes)
-    inEdges.set(node, []);
-  const outCount = /* @__PURE__ */ new Map();
-  for (const [from, tos] of outEdges) {
-    const valid = [...tos].filter((t) => rank.has(t));
-    outCount.set(from, valid.length);
-    for (const to of valid)
-      inEdges.get(to).push(from);
+
+// ../brain/dist/pipeline/scoring.js
+import { join as join7 } from "path";
+import { writeFile as writeFile7, mkdir as mkdir6, readFile as readFile6 } 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");
   }
-  for (let it = 0; it < iters; it++) {
-    const next = /* @__PURE__ */ new Map();
-    let dangling = 0;
-    for (const node of nodes) {
-      if ((outCount.get(node) || 0) === 0)
-        dangling += rank.get(node);
-    }
-    for (const node of nodes) {
-      let sum = 0;
-      for (const from of inEdges.get(node)) {
-        sum += rank.get(from) / (outCount.get(from) || 1);
-      }
-      next.set(node, (1 - damping) / n + damping * (sum + dangling / n));
-    }
-    for (const node of nodes)
-      rank.set(node, next.get(node));
+  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;
+  if (file.riskTypes.includes("registry_bottleneck")) {
+    if (file.canonicalSeverity < 4)
+      file.canonicalSeverity = 4;
+    file.canonicalLoadBearing = true;
   }
-  let max = 0;
-  for (const v of rank.values())
-    max = Math.max(max, v);
-  if (max > 0)
-    for (const node of nodes)
-      rank.set(node, rank.get(node) / max);
-  return rank;
 }
-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) {
-      const neighbors = adjacency.get(node);
-      if (!neighbors || neighbors.size === 0)
-        continue;
-      const counts = /* @__PURE__ */ new Map();
-      for (const [nb, weight] of neighbors) {
-        const l = label.get(nb);
-        counts.set(l, (counts.get(l) || 0) + weight);
-      }
-      let best = label.get(node), bestCount = -1;
-      for (const [l, c] of counts) {
-        if (c > bestCount || c === bestCount && l < best) {
-          best = l;
-          bestCount = c;
-        }
-      }
-      if (best !== label.get(node)) {
-        label.set(node, best);
-        changed = true;
-      }
-    }
-    if (!changed)
-      break;
+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");
   }
-  return label;
+  if (sideEffectProfile.includes("calendar_mutation"))
+    outputs.push("calendar_event_id");
+  if (sideEffectProfile.includes("email_send"))
+    outputs.push("email_payload");
+  if (sideEffectProfile.includes("analytics_event"))
+    outputs.push("sdk_event_name");
+  if (frameworkRole === "hook" || frameworkRole === "store")
+    outputs.push("ui_state_transition");
+  if (productDomain === "data_table" && frameworkRole === "provider") {
+    outputs.push("ui_state_transition", "filter_state", "selected_segment");
+  }
+  return [...new Set(outputs)];
 }
-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 {
-    }
+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 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 (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 (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 (riskTypes.includes("registry_bottleneck")) {
+    return {
+      level: "high",
+      reason: "registry_bottleneck: central dispatch point \u2014 blast radius not measurable by fan-in alone."
+    };
   }
-  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);
-    }
+  if (loadBearingScore >= 5 || importedByCount >= 5) {
+    return { level: "medium", reason: `Imported by ${importedByCount} files. Interface changes will cascade.` };
   }
-  return { stack: [...stack], entrypoints };
+  if (productDomain === "data_table" && riskTypes.includes("state_machine")) {
+    return {
+      level: "medium",
+      reason: "data_table state machine: controls user-visible workflow state (filters, segments, pagination) \u2014 regression risk not captured by mutation scoring."
+    };
+  }
+  return { level: "low", reason: "Locally contained \u2014 limited blast radius." };
 }
-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 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.";
 }
-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 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");
   }
-  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;
-    }
-    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);
-    graph.nodes[rel] = { imports: importSpecs };
-    const frameworkRole = inferFrameworkRole(rel);
-    const productDomain = inferProductDomain(rel, importSpecs);
-    const sideEffectProfile = inferSideEffectProfile(source, importSpecs);
-    work.push({
-      abs: file,
-      rel,
-      lang,
-      source,
-      ast,
-      importSpecs,
-      pathDemote: pathDemoteReason(rel),
-      frameworkRole,
-      productDomain,
-      sideEffectProfile
+  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))
     });
   }
-  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());
+  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))
+    });
   }
-  for (const w of work) {
-    const distinctModules = /* @__PURE__ */ new Set();
-    for (const spec of w.importSpecs) {
-      distinctModules.add(spec);
-      const { resolved, isAlias } = resolveImport(spec, w.abs, w.lang, projectRoot, fileSet, basenameIndex);
-      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);
-      }
+  if (writeIntents.includes("create_recurring_booking")) {
+    probes.push({
+      name: "recurring booking",
+      scenario: "create recurring booking and assert recurring success behavior",
+      expectedObservable: ["booking_uid", "redirect_url"].filter((o) => observableOutputs.includes(o))
+    });
+  }
+  if (writeIntents.includes("handle_payment_webhook")) {
+    probes.push({
+      name: "payment webhook ingestion",
+      scenario: "send a valid payment webhook and assert booking/payment state updated",
+      expectedObservable: ["payment_status", "booking_uid", "http_status"].filter((o) => observableOutputs.includes(o))
+    });
+  }
+  if (writeIntents.includes("issue_auth_token")) {
+    probes.push({
+      name: "token issuance",
+      scenario: "complete OAuth flow and assert access token issued with correct scopes",
+      expectedObservable: ["auth_token", "http_status"].filter((o) => observableOutputs.includes(o))
+    });
+  }
+  return probes;
+}
+function deriveConfidence(fanIn, gravity) {
+  if (fanIn >= 10 && gravity >= 40)
+    return "high";
+  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.rawExcerpt,
+      evidenceHash: createHash("sha256").update(span.rawExcerpt).digest("hex").slice(0, 12)
+    }));
+    const displayEvidence = pf.hotSpans.map((span) => ({
+      file: pf.relativePath,
+      startLine: span.startLine,
+      endLine: span.endLine,
+      excerpt: span.snippet,
+      isTruncated: span.rawExcerpt.length > 2e3
+    }));
+    return {
+      path: pf.relativePath,
+      frameworkRole: pf.frameworkRole,
+      productDomain: pf.productDomain,
+      gravity: Math.round(pf.gravity),
+      heat: Math.round(pf.heat),
+      severity: pf.canonicalSeverity,
+      confidence,
+      isLoadBearing: pf.canonicalLoadBearing || loadBearingScore >= 5,
+      loadBearingScore,
+      riskTypes: pf.riskTypes,
+      sideEffectProfile: pf.sideEffectProfile,
+      blastRadius: pf.importedBy,
+      runtimeEntrypoints,
+      entrypointTraceStatus,
+      blockedImports: pf.importsUnresolved,
+      observableOutputs,
+      writeIntents: pf.writeIntents,
+      patchRisk,
+      safePatchStrategy: inferSafePatchStrategy(pf.riskTypes, pf.sideEffectProfile),
+      doNotTouch: inferDoNotTouch(pf.sideEffectProfile, pf.productDomain),
+      testProbes: inferTestProbes(pf.writeIntents, observableOutputs),
+      rawEvidence,
+      displayEvidence,
+      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 = await buildValidationReport(store, deltaTargets, projectRoot);
+  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}`);
+  }
+  for (const w of validationReport.warnings) {
+    console.error(`[vibe-splain] VALIDATION WARN [${w.rule}] ${w.file}: ${w.detail}`);
+  }
+  return { store, deltaTargets, validationReport };
+}
+async function buildValidationReport(store, deltaTargets, projectRoot) {
+  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;
     }
-    fanOut.set(w.rel, distinctModules.size);
-  }
-  const isRealSource = /* @__PURE__ */ new Map();
-  const demoteReason = /* @__PURE__ */ new Map();
-  for (const w of work) {
-    if (w.pathDemote) {
-      isRealSource.set(w.rel, false);
-      demoteReason.set(w.rel, w.pathDemote);
-    } else {
-      isRealSource.set(w.rel, true);
-      demoteReason.set(w.rel, null);
+    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;
     }
-  }
-  for (const w of work) {
-    if (!isRealSource.get(w.rel))
+    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 (entrypoints.has(w.rel))
+    }
+    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;
-    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");
     }
-  }
-  const realNodes = work.filter((w) => isRealSource.get(w.rel)).map((w) => w.rel);
-  const realSet = new Set(realNodes);
-  const outEdges = /* @__PURE__ */ new Map();
-  const undirected = /* @__PURE__ */ new Map();
-  for (const node of realNodes) {
-    outEdges.set(node, /* @__PURE__ */ new Set());
-    undirected.set(node, /* @__PURE__ */ new Map());
-  }
-  for (const w of work) {
-    if (!realSet.has(w.rel))
+    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;
-    for (const target of importsResolved.get(w.rel)) {
-      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 weight = wDir === tDir ? 1 : 0.5;
-      undirected.get(w.rel).set(target, weight);
-      undirected.get(target).set(w.rel, weight);
     }
-  }
-  const ranks = pageRank(realNodes, outEdges);
-  const communities = detectCommunities(realNodes, undirected);
-  const analyses = [];
-  const persisted = {};
-  for (const w of work) {
-    const real = isRealSource.get(w.rel);
-    const fanIn = [...importedBy.get(w.rel)].filter((src) => isRealSource.get(src)).length;
-    const centrality = real ? ranks.get(w.rel) || 0 : 0;
-    const gravitySignals = {
-      fanIn,
-      fanOut: fanOut.get(w.rel) || 0,
-      centrality,
-      cyclomatic: w.ast.cyclomatic,
-      publicSurface: w.ast.publicSurface,
-      loc: w.ast.loc
-    };
-    const depthRatio = (w.ast.cyclomatic + w.ast.maxNesting * 2) / Math.max(1, w.ast.publicSurface);
-    const depthFactor = Math.min(1, Math.log2(depthRatio + 1) / 3);
-    const adjustedCentrality = centrality * (0.3 + 0.7 * depthFactor);
-    let gravityRaw = adjustedCentrality * 50 + Math.log2(fanIn + 1) * 6 + Math.log2(w.ast.cyclomatic + 1) * 7 + Math.log2(w.ast.publicSurface + 1) * 2 + (w.ast.maxNesting >= 4 ? 5 : 0);
-    if (!real)
-      gravityRaw *= 0.2;
-    const gravity = Math.max(0, Math.min(100, gravityRaw));
-    const heatSignals = {
-      todos: w.ast.smells.filter((s) => s.kind === "todo").length,
-      suppressions: w.ast.smells.filter((s) => s.kind === "suppression").length,
-      swallowedCatches: w.ast.swallowedCatches,
-      maxNesting: w.ast.maxNesting,
-      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,
-      frameworkRole: w.frameworkRole,
-      productDomain: w.productDomain,
-      sideEffectProfile: w.sideEffectProfile
-    };
-    analyses.push(fa);
-    persisted[w.rel] = {
-      relativePath: w.rel,
-      language: w.lang,
-      isRealSource: real,
-      demoteReason: demoteReason.get(w.rel) || null,
-      gravity,
-      heat,
-      gravitySignals,
-      heatSignals,
-      smells: w.ast.smells,
-      pillarHint,
-      importedBy: [...importedBy.get(w.rel)].filter((src) => isRealSource.get(src)),
-      imports: [...importsResolved.get(w.rel)],
-      importsUnresolved: [...importsUnresolved.get(w.rel)],
-      frameworkRole: w.frameworkRole,
-      productDomain: w.productDomain,
-      sideEffectProfile: w.sideEffectProfile,
-      hotSpans: w.ast.hotSpans
-    };
-  }
-  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, persisted, communities, stack);
-  const topGravity = realAnalyses.slice(0, 12).map((a) => a.relativePath);
-  const topHeat = wildCandidates.slice(0, 12).map((a) => a.relativePath);
-  const map = {
-    stack,
-    entrypoints: [...entrypoints],
-    pillars,
-    fileCount: work.length,
-    realSourceCount: realAnalyses.length,
-    topGravity,
-    topHeat,
-    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
-  };
-}
-function buildPillars(real, persisted, 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);
+    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`
+      });
     }
-  }
-  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 (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);
+    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}`
+      });
     }
-    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 (pf.riskTypes.includes("registry_bottleneck")) {
+      if (pf.canonicalSeverity < 4)
+        errors.push({
+          file: pf.relativePath,
+          rule: "registry_bottleneck_severity",
+          detail: "registry_bottleneck file must have severity >= 4",
+          expected: ">=4",
+          actual: String(pf.canonicalSeverity)
+        });
+      if (!pf.canonicalLoadBearing)
+        errors.push({
+          file: pf.relativePath,
+          rule: "registry_bottleneck_load_bearing",
+          detail: "registry_bottleneck file must be load-bearing",
+          expected: "true",
+          actual: "false"
+        });
+      if (delta && delta.patchRisk.level !== "high" && delta.patchRisk.level !== "critical")
+        errors.push({
+          file: pf.relativePath,
+          rule: "registry_bottleneck_patch_risk",
+          detail: "registry_bottleneck file must have patch risk high or critical",
+          expected: "high|critical",
+          actual: delta?.patchRisk.level ?? "unknown"
         });
-      }
     }
-  }
-  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) });
-  }
-  const finalPillars = [];
-  for (const p of pillars) {
-    if (p.memberFiles.length > 15) {
-      const groups = /* @__PURE__ */ new Map();
-      for (const f of p.memberFiles) {
-        const pf = persisted[f];
-        const role = pf?.frameworkRole || "unknown";
-        const domain = pf?.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(f);
-      }
-      for (const [key, files] of groups) {
-        if (files.length > 0) {
-          finalPillars.push({
-            name: key,
-            description: `Subdivided from ${p.name}`,
-            memberFiles: files
-          });
-        }
+    if (pf.productDomain === "data_table" && pf.riskTypes.includes("state_machine") && delta?.patchRisk.level === "low") {
+      warnings.push({
+        file: pf.relativePath,
+        rule: "data_table_state_machine_risk",
+        detail: "data_table state machine should have at least medium patch risk"
+      });
+    }
+    passCount++;
+  }
+  const PAYMENT_PROVIDER_PATH_TERMS = ["stripe", "paypal", "btcpay", "btcpayserver", "alby", "hitpay", "payment"];
+  const PAYMENT_CONTENT_TERMS = [
+    "constructEvent",
+    "checkoutSession",
+    "paymentIntent",
+    "stripe-signature",
+    "webhook-signature",
+    "payment_mutation",
+    "paymentStatus",
+    "invoicePaid",
+    "chargeSucceeded"
+  ];
+  for (const [rel, pf] of Object.entries(store.files)) {
+    if (!pf.isRealSource)
+      continue;
+    const pathLower = rel.toLowerCase();
+    if (!pathLower.includes("webhook"))
+      continue;
+    const primaryTrigger = PAYMENT_PROVIDER_PATH_TERMS.some((t) => pathLower.includes(t));
+    let secondaryTrigger = false;
+    if (!primaryTrigger && pf.productDomain !== "payments_webhooks") {
+      try {
+        const src = await readFile6(join7(projectRoot, rel), "utf8");
+        secondaryTrigger = PAYMENT_CONTENT_TERMS.some((t) => src.includes(t));
+      } catch {
       }
-    } else {
-      finalPillars.push(p);
     }
-  }
-  const seen = /* @__PURE__ */ new Set();
-  for (const p of finalPillars) {
-    let n = p.name, i = 2;
-    while (seen.has(n)) {
-      n = `${p.name} ${i++}`;
+    if (!primaryTrigger && !secondaryTrigger)
+      continue;
+    const delta = deltaByPath.get(rel);
+    const triggerLabel = primaryTrigger ? "path" : "content";
+    const webhookChecks = [
+      [
+        pf.productDomain !== "payments_webhooks",
+        "webhook_domain",
+        `Payment webhook (${triggerLabel} trigger) not classified as payments_webhooks`
+      ],
+      [
+        !pf.sideEffectProfile.includes("webhook_ingress"),
+        "webhook_ingress_missing",
+        `Payment webhook (${triggerLabel} trigger) missing webhook_ingress side effect`
+      ],
+      [
+        !pf.sideEffectProfile.includes("payment_mutation"),
+        "webhook_payment_mutation_missing",
+        `Payment webhook (${triggerLabel} trigger) missing payment_mutation side effect`
+      ],
+      [
+        !pf.writeIntents.includes("handle_payment_webhook"),
+        "webhook_write_intent_missing",
+        `Payment webhook (${triggerLabel} trigger) missing handle_payment_webhook write intent`
+      ],
+      [
+        !!delta && delta.patchRisk.level !== "high" && delta.patchRisk.level !== "critical",
+        "webhook_patch_risk",
+        `Payment webhook (${triggerLabel} trigger) patchRisk must be high or critical`
+      ],
+      [
+        !pf.canonicalLoadBearing,
+        "webhook_load_bearing",
+        `Payment webhook (${triggerLabel} trigger) must be load-bearing`
+      ]
+    ];
+    for (const [condition, rule, detail] of webhookChecks) {
+      if (condition)
+        errors.push({ file: rel, rule, detail });
     }
-    p.name = n;
-    seen.add(n);
   }
-  return finalPillars;
-}
-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 {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    passed: errors.length === 0,
+    errors,
+    warnings,
+    summary: { errorCount: errors.length, warningCount: warnings.length, passCount }
   };
-  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 (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];
-  }
-  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);
+
+// ../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"
     }
-    const top = [...segCounts.entries()].sort((a, b) => b[1] - a[1])[0];
-    if (top)
-      return titleCase(top[0]);
-  }
-  const topFile = basename(files[0].relativePath, extname(files[0].relativePath));
-  return titleCase(topFile);
+  };
 }
-function titleCase(s) {
-  return s.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+
+// ../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 readFile7(absPath, "utf8");
   } catch {
     return null;
   }
@@ -2119,20 +2655,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
   };
@@ -2140,16 +2675,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 readFile8, 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 readFile8(dossierPath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -2161,33 +2696,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 readFile8(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)
@@ -2207,8 +2742,8 @@ function validateMermaidNodeCount(diagram) {
 // ../brain/dist/watcher.js
 import chokidar from "chokidar";
 import { createHash as createHash2 } from "crypto";
-import { readFile as readFile6 } from "fs/promises";
-import { join as join6 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join10 } from "path";
 function startWatcher(projectRoot, watchedPaths) {
   const watcher = chokidar.watch(watchedPaths.length > 0 ? watchedPaths : projectRoot, {
     ignoreInitial: true,
@@ -2220,14 +2755,14 @@ function startWatcher(projectRoot, watchedPaths) {
       const dossier = await readDossier(projectRoot);
       if (!dossier)
         return;
-      const content = await readFile6(filepath, "utf8");
+      const content = await readFile9(filepath, "utf8");
       const newHash = createHash2("sha256").update(content).digest("hex");
       let mutated = false;
       for (const pillar of dossier.pillars) {
         for (const card of pillar.decisions) {
           if (!card.primaryFile)
             continue;
-          const absMatch = filepath === 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;
@@ -2286,7 +2821,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,
@@ -2382,8 +2932,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 readFile10 } 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.",
@@ -2403,8 +2953,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).`);
@@ -2428,7 +2978,7 @@ async function handleGetFileContext(args) {
     smellSpans: evidence.smellSpans
   };
   if (full) {
-    result.source = await readFile7(fullPath, "utf8");
+    result.source = await readFile10(fullPath, "utf8");
   }
   return result;
 }
@@ -2436,8 +2986,8 @@ async function handleGetFileContext(args) {
 // dist/mcp/tools/write_decision_card.js
 import { v4 as uuidv4 } from "uuid";
 import { createHash as createHash3 } from "crypto";
-import { readFile as readFile8 } from "fs/promises";
-import { join as join8 } from "path";
+import { readFile as readFile11 } 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");
@@ -2529,7 +3079,7 @@ 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 readFile11(join12(projectRoot, primaryFile), "utf8");
   } catch {
   }
   const hash = createHash3("sha256").update(primaryContent).digest("hex");
@@ -2773,7 +3323,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 () => ({
@@ -2898,7 +3448,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.4.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();