vibe-splain 3.4.1 → 3.4.2

package/dist/index.js

@@ -6,8 +6,9 @@ import { Command } from "commander";
 // dist/commands/install.js
 import { readFile, writeFile } from "fs/promises";
 import { existsSync } from "fs";
-import { join } from "path";
+import { join, dirname } from "path";
 import { homedir } from "os";
+import { fileURLToPath } from "url";
 function expandPath(p) {
   if (p.startsWith("~")) {
     return join(homedir(), p.slice(1));
@@ -30,8 +31,40 @@ var MCP_ENTRY = {
   command: "npx",
   args: ["-y", "vibe-splain", "serve"]
 };
+var HOOK_MATCHER = "Edit|Write|MultiEdit";
+var DEFAULT_HOOK_COMMAND = "npx -y vibe-splain hook pretooluse";
+function addPreToolUseHook(config, hookPath) {
+  if (!config.hooks)
+    config.hooks = {};
+  if (!Array.isArray(config.hooks.PreToolUse))
+    config.hooks.PreToolUse = [];
+  const hookCommand = hookPath ? `node "${hookPath}"` : DEFAULT_HOOK_COMMAND;
+  const already = config.hooks.PreToolUse.some((entry) => Array.isArray(entry?.hooks) && entry.hooks.some((h) => typeof h?.command === "string" && (h.command.includes("vibe-splain hook pretooluse") || h.command.includes("hook.js"))));
+  if (already) {
+    config.hooks.PreToolUse = config.hooks.PreToolUse.map((entry) => {
+      if (Array.isArray(entry?.hooks)) {
+        return {
+          ...entry,
+          hooks: entry.hooks.map((h) => {
+            if (typeof h?.command === "string" && (h.command.includes("vibe-splain hook pretooluse") || h.command.includes("hook.js"))) {
+              return { ...h, command: hookCommand };
+            }
+            return h;
+          })
+        };
+      }
+      return entry;
+    });
+    return config;
+  }
+  config.hooks.PreToolUse.push({
+    matcher: HOOK_MATCHER,
+    hooks: [{ type: "command", command: hookCommand }]
+  });
+  return config;
+}
 async function installCommand() {
-  console.error("\n\u{1F527} VIBE-SPLAIN Installer\n");
+  console.error("\n\u{1F527} vibe-splain Installer\n");
   let patchedCount = 0;
   for (const agent of AGENT_CONFIGS) {
     const resolvedPath = expandPath(agent.path);
@@ -48,15 +81,21 @@ async function installCommand() {
         console.error(`    \u26A0 Could not parse JSON, skipping`);
         continue;
       }
-      if (config.mcpServers?.["vibe-splain"]) {
+      const before = JSON.stringify(config);
+      if (!config.mcpServers)
+        config.mcpServers = {};
+      if (!config.mcpServers["vibe-splain"])
+        config.mcpServers["vibe-splain"] = MCP_ENTRY;
+      if (agent.name === "Claude Code CLI") {
+        const __dirname3 = dirname(fileURLToPath(import.meta.url));
+        const hookPath = join(__dirname3, "..", "hook.js");
+        addPreToolUseHook(config, hookPath);
+      }
+      if (JSON.stringify(config) === before) {
         console.error(`    \u2713 Already configured, skipping`);
         patchedCount++;
         continue;
       }
-      if (!config.mcpServers) {
-        config.mcpServers = {};
-      }
-      config.mcpServers["vibe-splain"] = MCP_ENTRY;
       await writeFile(resolvedPath, JSON.stringify(config, null, 2), "utf8");
       console.error(`    \u2705 Patched successfully`);
       patchedCount++;
@@ -89,19 +128,19 @@ import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema
 
 // ../brain/dist/scanner.js
 import { extname as extname4 } from "path";
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 
 // ../brain/dist/pipeline/orchestrator.js
 import { join as join7 } from "path";
 
 // ../brain/dist/pipeline/inventory.js
 import Parser from "web-tree-sitter";
-import { join as join2, dirname, relative, extname, basename, sep } from "path";
-import { fileURLToPath } from "url";
+import { join as join2, dirname as dirname2, relative, extname, basename, sep } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { createRequire } from "module";
 import { readFile as readFile2, readdir, writeFile as writeFile2, mkdir } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-var __dirname = dirname(fileURLToPath(import.meta.url));
+var __dirname = dirname2(fileURLToPath2(import.meta.url));
 var require2 = createRequire(import.meta.url);
 var _parser = null;
 var langCache = /* @__PURE__ */ new Map();
@@ -129,7 +168,7 @@ var LANG_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 wasmsDir = dirname2(require2.resolve("tree-sitter-wasms/package.json"));
     const p = join2(wasmsDir, "out", file);
     if (existsSync2(p))
       return p;
@@ -319,19 +358,6 @@ function inferProductDomain(relPath, importSpecs) {
   if (/\.generated\.|__generated__|\.prisma\//.test(p)) {
     return "generated_noise";
   }
-  if (p.includes("booking-audit") || p.includes("bookingaudit"))
-    return "booking_audit";
-  if (p.includes("/pages/api/book/") || p.includes("/api/book/") || p.includes("/booking-successful/") || p.includes("/reschedule/") || p.includes("booking-page-wrapper"))
-    return "booking_creation";
-  if (p.includes("bookeventform") || p.includes("availabletimes") || p.includes("availabletimeslots") || p.includes("usebookings") || p.includes("/book/") && !p.includes("booking-audit"))
-    return "booking_ui_delegate";
-  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/")))
@@ -342,28 +368,6 @@ function inferProductDomain(relPath, importSpecs) {
     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";
@@ -719,7 +723,7 @@ async function detectStackAndEntrypoints(projectRoot, files) {
     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)
+    if (/^index\.(ts|tsx|js|jsx|mjs|cjs)$/.test(b) && dirname2(r).split(sep).length <= 2)
       entrypoints.add(r);
     if (b === "main.go" && r.includes("cmd" + sep))
       entrypoints.add(r);
@@ -1198,7 +1202,7 @@ async function runInventory(projectRoot) {
 }
 
 // ../brain/dist/pipeline/resolution.js
-import { join as join3, dirname as dirname2, relative as relative2, extname as extname2, sep as sep2 } from "path";
+import { join as join3, dirname as dirname3, relative as relative2, extname as extname2, sep as sep2 } from "path";
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 function parseJsonLenient(text) {
@@ -1213,10 +1217,10 @@ async function discoverAllTsConfigs(dir, projectRoot, maxDepth = 4) {
   const result = {};
   if (maxDepth < 0)
     return result;
-  const { readdir: readdir3 } = await import("fs/promises");
+  const { readdir: readdir2 } = await import("fs/promises");
   let entries = [];
   try {
-    entries = await readdir3(dir, { withFileTypes: true });
+    entries = await readdir2(dir, { withFileTypes: true });
   } catch {
     return result;
   }
@@ -1250,9 +1254,9 @@ async function extractTsConfigPaths(tsconfigPath, projectRoot, depth = 0) {
   if (typeof parsed.extends === "string") {
     let baseFile = parsed.extends;
     if (baseFile.startsWith(".")) {
-      baseFile = join3(dirname2(tsconfigPath), baseFile);
+      baseFile = join3(dirname3(tsconfigPath), baseFile);
     } else {
-      let currentDir = dirname2(tsconfigPath);
+      let currentDir = dirname3(tsconfigPath);
       let found = false;
       while (currentDir.length >= projectRoot.length || currentDir === projectRoot) {
         const candidate = join3(currentDir, "node_modules", baseFile + (baseFile.endsWith(".json") ? "" : ".json"));
@@ -1261,7 +1265,7 @@ async function extractTsConfigPaths(tsconfigPath, projectRoot, depth = 0) {
           found = true;
           break;
         }
-        const parent = dirname2(currentDir);
+        const parent = dirname3(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -1276,7 +1280,7 @@ async function extractTsConfigPaths(tsconfigPath, projectRoot, depth = 0) {
     Object.assign(result, base);
   }
   const opts = parsed.compilerOptions || {};
-  const baseUrl = typeof opts.baseUrl === "string" ? join3(dirname2(tsconfigPath), opts.baseUrl) : dirname2(tsconfigPath);
+  const baseUrl = typeof opts.baseUrl === "string" ? join3(dirname3(tsconfigPath), opts.baseUrl) : dirname3(tsconfigPath);
   if (typeof opts.baseUrl === "string") {
     const relBase = relative2(projectRoot, baseUrl);
     if (relBase && relBase !== ".") {
@@ -1312,10 +1316,10 @@ async function discoverWorkspacePackages(projectRoot) {
     const absPrefix = join3(projectRoot, prefix);
     if (!existsSync3(absPrefix))
       continue;
-    const { readdir: readdir3 } = await import("fs/promises");
+    const { readdir: readdir2 } = await import("fs/promises");
     let entries = [];
     try {
-      const dirents = await readdir3(absPrefix, { withFileTypes: true });
+      const dirents = await readdir2(absPrefix, { withFileTypes: true });
       entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
     } catch {
       continue;
@@ -1382,9 +1386,9 @@ function resolvePython(spec, fromAbs, projectRoot, fileSet) {
   let modulePath;
   if (spec.startsWith(".")) {
     const dots = spec.match(/^\.+/)[0].length;
-    let dir = dirname2(fromAbs);
+    let dir = dirname3(fromAbs);
     for (let i = 1; i < dots; i++)
-      dir = dirname2(dir);
+      dir = dirname3(dir);
     const rest = spec.slice(dots).replace(/\./g, sep2);
     modulePath = rest ? join3(dir, rest) : dir;
   } else {
@@ -1418,7 +1422,7 @@ function resolveImportWithAliasMap(spec, fromAbs, lang, projectRoot, fileSet, ba
   }
   if (lang === "typescript" || lang === "tsx" || lang === "javascript") {
     if (spec.startsWith(".")) {
-      const base = join3(dirname2(fromAbs), spec);
+      const base = join3(dirname3(fromAbs), spec);
       return { resolved: tryJsCandidates(base, projectRoot, fileSet), isAlias: false };
     }
     for (const [prefix, replacement] of Object.entries(aliasMap.resolvedAliases)) {
@@ -1531,8 +1535,814 @@ async function runResolution(projectRoot, inv) {
 }
 
 // ../brain/dist/pipeline/classification.js
-import { join as join4, basename as basename2, extname as extname3, sep as sep3 } from "path";
+import { join as join5, basename as basename4, extname as extname3, sep as sep3 } from "path";
 import { writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
+
+// ../brain/dist/pipeline/adapters/types.js
+function emptyAdapterStageResult() {
+  return {
+    firedAdapterIds: [],
+    liftByFile: /* @__PURE__ */ new Map(),
+    severityBoostByFile: /* @__PURE__ */ new Map(),
+    loadBearingBoostByFile: /* @__PURE__ */ new Map(),
+    classificationByFile: /* @__PURE__ */ new Map(),
+    sideEffectsByFile: /* @__PURE__ */ new Map(),
+    writeIntentsByFile: /* @__PURE__ */ new Map(),
+    pillarLabelsByFile: /* @__PURE__ */ new Map(),
+    pillarRenames: /* @__PURE__ */ new Map(),
+    surfacePatterns: [],
+    metrics: {}
+  };
+}
+
+// ../brain/dist/pipeline/adapters/registry.js
+var AdapterRegistry = class {
+  adapters = [];
+  /** Register a compiled-in adapter. Re-registering the same id replaces it. */
+  register(adapter) {
+    this.adapters = this.adapters.filter((a) => a.id !== adapter.id);
+    this.adapters.push(adapter);
+  }
+  /** All registered adapters (for tests/introspection). */
+  list() {
+    return [...this.adapters].sort((a, b) => a.id.localeCompare(b.id));
+  }
+  /** Adapters whose detect() matches, in deterministic id order. */
+  select(ctx) {
+    return this.adapters.filter((a) => {
+      try {
+        return a.detect(ctx);
+      } catch {
+        return false;
+      }
+    }).sort((a, b) => a.id.localeCompare(b.id));
+  }
+  /**
+   * Run every matching adapter and compose their contributions into one
+   * order-independent result. Returns the identity result when nothing matches.
+   */
+  runStage(ctx) {
+    const matched = this.select(ctx);
+    if (matched.length === 0)
+      return emptyAdapterStageResult();
+    const out = emptyAdapterStageResult();
+    out.firedAdapterIds = matched.map((a) => a.id);
+    const execRoleCandidates = /* @__PURE__ */ new Map();
+    for (const adapter of matched) {
+      const lift = adapter.computeBehavioralLift?.(ctx);
+      if (lift) {
+        for (const [rel, v] of Object.entries(lift.byFile)) {
+          if (v < 0)
+            continue;
+          out.liftByFile.set(rel, (out.liftByFile.get(rel) ?? 0) + v);
+        }
+      }
+      const sev = adapter.applySeverityPolicy?.(ctx);
+      if (sev) {
+        for (const [rel, v] of Object.entries(sev.byFile)) {
+          if (v < 0)
+            continue;
+          out.severityBoostByFile.set(rel, Math.max(out.severityBoostByFile.get(rel) ?? 0, v));
+        }
+      }
+      const lb = adapter.applyLoadBearingPolicy?.(ctx);
+      if (lb) {
+        for (const [rel, v] of Object.entries(lb.byFile)) {
+          if (v < 0)
+            continue;
+          out.loadBearingBoostByFile.set(rel, Math.max(out.loadBearingBoostByFile.get(rel) ?? 0, v));
+        }
+      }
+      const cls = adapter.classify?.(ctx);
+      if (cls) {
+        for (const [rel, c] of Object.entries(cls.byFile)) {
+          const cur = out.classificationByFile.get(rel) ?? { domainTags: [] };
+          if (c.adapterDomain != null)
+            cur.adapterDomain = cur.adapterDomain ?? c.adapterDomain;
+          if (c.domainTags)
+            cur.domainTags = unionSorted(cur.domainTags, c.domainTags);
+          if (c.executionRole != null) {
+            const s = execRoleCandidates.get(rel) ?? /* @__PURE__ */ new Set();
+            s.add(c.executionRole);
+            execRoleCandidates.set(rel, s);
+          }
+          out.classificationByFile.set(rel, cur);
+        }
+      }
+      const eff = adapter.interpretSideEffects?.(ctx);
+      if (eff) {
+        for (const [rel, arr] of Object.entries(eff.byFile)) {
+          out.sideEffectsByFile.set(rel, unionSorted(out.sideEffectsByFile.get(rel) ?? [], arr));
+        }
+      }
+      const wi = adapter.inferWriteIntents?.(ctx);
+      if (wi) {
+        for (const [rel, arr] of Object.entries(wi.byFile)) {
+          out.writeIntentsByFile.set(rel, unionSorted(out.writeIntentsByFile.get(rel) ?? [], arr));
+        }
+      }
+      const pl = adapter.labelPillars?.(ctx);
+      if (pl?.renames) {
+        for (const [from, to] of Object.entries(pl.renames)) {
+          if (!out.pillarRenames.has(from))
+            out.pillarRenames.set(from, to);
+        }
+      }
+      if (pl?.byFile) {
+        for (const [rel, label] of Object.entries(pl.byFile)) {
+          if (!out.pillarLabelsByFile.has(rel))
+            out.pillarLabelsByFile.set(rel, label);
+        }
+      }
+      const sp = adapter.getSurfacePatterns?.();
+      if (sp)
+        out.surfacePatterns.push(...sp);
+      const met = adapter.getMetrics?.();
+      if (met) {
+        for (const [k, v] of Object.entries(met)) {
+          out.metrics[k] = (out.metrics[k] ?? 0) + v;
+        }
+      }
+    }
+    for (const [rel, roles] of execRoleCandidates) {
+      const chosen = [...roles].sort()[0];
+      const cur = out.classificationByFile.get(rel) ?? { domainTags: [] };
+      cur.executionRole = chosen;
+      out.classificationByFile.set(rel, cur);
+    }
+    return out;
+  }
+};
+function unionSorted(a, b) {
+  return [.../* @__PURE__ */ new Set([...a, ...b])].sort();
+}
+var adapterRegistry = new AdapterRegistry();
+
+// ../brain/dist/pipeline/adapters/calcom.js
+function detectCalcom(ctx) {
+  const THRESHOLD = 5;
+  let hits = 0;
+  for (const f of ctx.files) {
+    if (f.importSpecs.some((s) => s.startsWith("@calcom/"))) {
+      if (++hits >= THRESHOLD)
+        return true;
+    }
+  }
+  return false;
+}
+var CALCOM_SURFACE_PATTERNS = [
+  {
+    domain: "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]
+  },
+  {
+    domain: "booking_ui_delegate",
+    expected: [/book/i, /booking/i, /reschedule/i, /event-type/i, /event-types/i],
+    wrong: [/settings/i, /admin/i, /onboarding/i]
+  },
+  {
+    domain: "payments_webhooks",
+    expected: [/webhook/i, /stripe/i, /payment/i],
+    wrong: [/settings/i, /onboarding/i, /profile/i]
+  },
+  {
+    domain: "auth_oauth",
+    expected: [/oauth/i, /callback/i, /auth/i, /signin/i, /login/i],
+    wrong: [/booking/i, /payment/i, /settings/i]
+  }
+];
+function calcomWriteIntents(ctx) {
+  const byFile = {};
+  const adapterEffectsResult = calcomInterpretSideEffects(ctx);
+  for (const f of ctx.files) {
+    const rel = f.rel;
+    const intents = [];
+    const d = inferCalcomDomain(rel, f.importSpecs) ?? f.productDomain;
+    if (d === "booking_creation" || d === "booking_ui_delegate") {
+      intents.push("create_booking");
+      if (rel.includes("reschedule") || rel.includes("Reschedule"))
+        intents.push("reschedule_booking");
+      if (rel.includes("recurring") || rel.includes("Recurring"))
+        intents.push("create_recurring_booking");
+    }
+    if (d === "booking_management")
+      intents.push("cancel_booking");
+    if (d === "event_type_configuration")
+      intents.push("update_event_type");
+    if (d === "availability")
+      intents.push("update_availability");
+    if (d === "payments")
+      intents.push("create_payment");
+    if (d === "payments_webhooks")
+      intents.push("handle_payment_webhook");
+    if (d === "auth_oauth") {
+      intents.push("issue_auth_token");
+      intents.push("refresh_auth_token");
+    }
+    const adapterEffects = adapterEffectsResult.byFile[rel] || [];
+    if (adapterEffects.includes("webhook_delivery"))
+      intents.push("send_webhook");
+    if (d === "settings")
+      intents.push("update_user_settings");
+    if (intents.length > 0)
+      byFile[rel] = intents;
+  }
+  return { byFile };
+}
+var CALCOM_TAXONOMY = {
+  booking_creation: { adapterDomain: "booking", executionRole: "mutation" },
+  booking_management: { adapterDomain: "booking", executionRole: "mutation" },
+  booking_audit: { adapterDomain: "booking", executionRole: "read" },
+  booking_ui_delegate: { adapterDomain: "booking", executionRole: "ui_delegate" },
+  event_type_configuration: { adapterDomain: "event_types", executionRole: "config" },
+  availability: { adapterDomain: "availability", executionRole: "config" },
+  auth: { adapterDomain: "auth", executionRole: "auth" },
+  auth_oauth: { adapterDomain: "auth", executionRole: "auth" },
+  payments: { adapterDomain: "payments", executionRole: "mutation" },
+  payments_webhooks: { adapterDomain: "payments", executionRole: "ingress" },
+  webhooks: { adapterDomain: "webhooks", executionRole: "ingress" },
+  apps_marketplace: { adapterDomain: "apps", executionRole: "config" },
+  calendar_integrations: { adapterDomain: "calendar", executionRole: "integration" },
+  video: { adapterDomain: "video", executionRole: "integration" },
+  onboarding: { adapterDomain: "onboarding", executionRole: "flow" },
+  settings: { adapterDomain: "settings", executionRole: "config" },
+  admin: { adapterDomain: "admin", executionRole: "config" },
+  notifications: { adapterDomain: "notifications", executionRole: "delivery" },
+  embed: { adapterDomain: "embed", executionRole: "ui_delegate" }
+};
+function inferCalcomDomain(relPath, importSpecs) {
+  const p = relPath.toLowerCase().replace(/\\/g, "/");
+  if (/\.test\.|\.spec\.|__tests__|\/e2e\/|\/playwright\/|\/cypress\//.test(p))
+    return void 0;
+  if (/\.generated\.|__generated__|\.prisma\//.test(p))
+    return void 0;
+  if (p.includes("booking-audit") || p.includes("bookingaudit"))
+    return "booking_audit";
+  if (p.includes("/pages/api/book/") || p.includes("/api/book/") || p.includes("/booking-successful/") || p.includes("/reschedule/") || p.includes("booking-page-wrapper"))
+    return "booking_creation";
+  if (p.includes("bookeventform") || p.includes("availabletimes") || p.includes("availabletimeslots") || p.includes("usebookings") || p.includes("/book/") && !p.includes("booking-audit"))
+    return "booking_ui_delegate";
+  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";
+  return void 0;
+}
+function calcomClassify(ctx) {
+  const byFile = {};
+  for (const f of ctx.files) {
+    if (f.productDomain === "test_infrastructure" || f.productDomain === "generated_noise" || f.productDomain === "routing_infrastructure")
+      continue;
+    const domain = inferCalcomDomain(f.rel, f.importSpecs);
+    if (!domain)
+      continue;
+    const t = CALCOM_TAXONOMY[domain];
+    if (t) {
+      byFile[f.rel] = {
+        adapterDomain: t.adapterDomain,
+        domainTags: [domain],
+        executionRole: t.executionRole
+      };
+    } else {
+      byFile[f.rel] = {
+        adapterDomain: "unknown",
+        domainTags: [domain],
+        executionRole: "unknown"
+      };
+    }
+  }
+  return { byFile };
+}
+function calcomInterpretSideEffects(ctx) {
+  const byFile = {};
+  for (const f of ctx.files) {
+    const domain = [];
+    const source = f.source;
+    const d = f.productDomain;
+    const frameworkRole = f.frameworkRole;
+    if (/createBooking|handleNewBooking|cancelBooking|rescheduleBooking|handleBooking|createRecurring/.test(source) || d === "booking_creation" && /useMutation\b|\.mutate\b|\.mutateAsync\b/.test(source))
+      domain.push("booking_mutation");
+    if (/stripe\.webhooks\.(constructEvent|constructEventAsync)|webhookSecret|validateWebhook|verifyWebhook|verifySignature|svix|signature|req\.body|req\.rawBody/.test(source) || d === "payments_webhooks" && frameworkRole === "pages_api_route")
+      domain.push("webhook_ingress");
+    if (f.importSpecs.some((s) => /stripe|paypal|btcpay|alby/.test(s.toLowerCase())) || /stripe\.|paymentIntent|createPaymentIntent|confirmPayment|createCharge/.test(source) || d === "payments_webhooks" && (domain.includes("webhook_ingress") || source.includes("webhook")))
+      domain.push("payment_mutation");
+    if (/signIn\b|signOut\b|createSession|destroySession|issueToken|refreshToken|getToken/.test(source)) {
+      domain.push("auth_token_mutation");
+    }
+    if (/triggerWebhook|sendWebhook|webhook\.send\b/.test(source))
+      domain.push("webhook_delivery");
+    if (/createCalendarEvent|updateCalendarEvent|deleteCalendarEvent|calendar\.events\.(insert|update|delete|patch)/.test(source)) {
+      domain.push("calendar_mutation");
+    }
+    if (domain.length > 0)
+      byFile[f.rel] = domain;
+  }
+  return { byFile };
+}
+var CALCOM_SIDE_EFFECT_SEVERITY = {
+  booking_mutation: 4,
+  payment_mutation: 4,
+  auth_token_mutation: 4,
+  webhook_delivery: 3,
+  webhook_ingress: 3,
+  calendar_mutation: 3
+};
+function calcomLoadBearingPolicy(ctx) {
+  const byFile = {};
+  const adapterEffectsResult = calcomInterpretSideEffects(ctx);
+  for (const f of ctx.files) {
+    let score = 0;
+    const adapterEffects = adapterEffectsResult.byFile[f.rel] || [];
+    if (adapterEffects.includes("booking_mutation"))
+      score += 3;
+    if (adapterEffects.includes("payment_mutation"))
+      score += 3;
+    if (adapterEffects.includes("auth_token_mutation"))
+      score += 3;
+    if (adapterEffects.includes("webhook_delivery"))
+      score += 2;
+    if (adapterEffects.includes("webhook_ingress"))
+      score += 2;
+    if (adapterEffects.includes("calendar_mutation"))
+      score += 2;
+    if (score > 0)
+      byFile[f.rel] = score;
+  }
+  return { byFile };
+}
+function calcomSeverityPolicy(ctx) {
+  const byFile = {};
+  const adapterEffectsResult = calcomInterpretSideEffects(ctx);
+  for (const f of ctx.files) {
+    let score = 0;
+    for (const e of f.sideEffectProfile)
+      score += CALCOM_SIDE_EFFECT_SEVERITY[e] ?? 0;
+    const adapterEffects = adapterEffectsResult.byFile[f.rel] || [];
+    for (const e of adapterEffects)
+      score += CALCOM_SIDE_EFFECT_SEVERITY[e] ?? 0;
+    const d = inferCalcomDomain(f.rel, f.importSpecs) ?? f.productDomain;
+    if (d === "booking_creation")
+      score += 3;
+    if (d === "payments" || d === "payments_webhooks")
+      score += 3;
+    if (d === "auth_oauth")
+      score += 3;
+    if (d === "webhooks")
+      score += 2;
+    if (score > 0)
+      byFile[f.rel] = score;
+  }
+  return { byFile };
+}
+function calcomLabelPillars(ctx) {
+  const byFile = {};
+  function titleCase2(s) {
+    return s.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  }
+  for (const f of ctx.files) {
+    const domain = inferCalcomDomain(f.rel, f.importSpecs) ?? f.productDomain;
+    if (domain === "unknown" || domain === "routing_infrastructure" || domain === "test_infrastructure" || domain === "generated_noise") {
+      continue;
+    }
+    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"
+    };
+    byFile[f.rel] = labels[domain] || titleCase2(domain.replace(/_/g, " "));
+  }
+  return { byFile };
+}
+var calcomAdapter = {
+  id: "calcom",
+  detect: detectCalcom,
+  // Relocated/mirrored hooks (ADR-034), one at a time. Still core-authoritative:
+  // ProductDomain assignment, sideEffectProfile, final severity, pillar labels.
+  classify: calcomClassify,
+  interpretSideEffects: calcomInterpretSideEffects,
+  applySeverityPolicy: calcomSeverityPolicy,
+  applyLoadBearingPolicy: calcomLoadBearingPolicy,
+  getSurfacePatterns: () => CALCOM_SURFACE_PATTERNS,
+  inferWriteIntents: calcomWriteIntents,
+  labelPillars: calcomLabelPillars
+};
+
+// ../brain/dist/pipeline/adapters/n8n.js
+import { readFileSync, existsSync as existsSync4 } from "fs";
+import { join as join4, basename as basename3 } from "path";
+
+// ../brain/dist/pipeline/adapters/lift.js
+function capComponent(value, cap) {
+  return Math.max(0, Math.min(value, cap));
+}
+function boundedSum(values, cap) {
+  const sum = values.reduce((a, b) => a + b, 0);
+  return capComponent(sum, cap);
+}
+
+// ../brain/dist/pipeline/adapters/resolution.js
+import { basename as basename2 } from "path";
+function mapPath(path2, rules) {
+  let current = path2;
+  for (const rule of rules) {
+    current = current.replace(rule.pattern, rule.replacement);
+  }
+  return current;
+}
+function getCanonicalName(path2, suffixes) {
+  let base = basename2(path2);
+  for (const suffix of suffixes) {
+    base = base.replace(suffix, "");
+  }
+  return base;
+}
+function resolveSourceFiles(files, options) {
+  const matches = [];
+  if (options.expectedPath && files.some((f) => f.rel === options.expectedPath)) {
+    matches.push(options.expectedPath);
+  }
+  const filter2 = options.filter ?? (() => true);
+  if (options.aliases) {
+    for (const alias of options.aliases) {
+      const found = files.find((f) => filter2(f.rel) && f.rel.endsWith(`/${alias}`));
+      if (found && !matches.includes(found.rel)) {
+        matches.push(found.rel);
+      }
+    }
+  }
+  if (options.versionPattern) {
+    const { baseName, suffix, versionPrefix = "V" } = options.versionPattern;
+    const escapedBase = escapeRegExp(baseName);
+    const escapedPrefix = escapeRegExp(versionPrefix);
+    const escapedSuffix = escapeRegExp(suffix);
+    const versionRegex = new RegExp(`^${escapedBase}${escapedPrefix}.*${escapedSuffix}$`);
+    const foundGeneral = files.filter((f) => {
+      if (!filter2(f.rel))
+        return false;
+      return versionRegex.test(basename2(f.rel));
+    });
+    for (const f of foundGeneral) {
+      if (!matches.includes(f.rel)) {
+        matches.push(f.rel);
+      }
+    }
+  }
+  return matches;
+}
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var ResolutionTracker = class {
+  stats = {};
+  constructor(categories = []) {
+    for (const category of categories) {
+      this.ensureCategory(category);
+    }
+  }
+  ensureCategory(category) {
+    if (!this.stats[category]) {
+      this.stats[category] = { registered: 0, resolved: 0, unresolved: 0 };
+    }
+  }
+  /** Registers manifest item counts for a category */
+  register(category, count = 1) {
+    this.ensureCategory(category);
+    this.stats[category].registered += count;
+  }
+  /** Increments successful resolution count for a category */
+  resolve(category, count = 1) {
+    this.ensureCategory(category);
+    this.stats[category].resolved += count;
+  }
+  /** Increments unresolved count for a category */
+  unresolve(category, count = 1) {
+    this.ensureCategory(category);
+    this.stats[category].unresolved += count;
+  }
+  /** Generates the metrics Record with namespaced keys, e.g. `<prefix>.<category>.registered` */
+  getMetrics(prefix) {
+    const metrics = {};
+    for (const [category, stat2] of Object.entries(this.stats)) {
+      metrics[`${prefix}.${category}.registered`] = stat2.registered;
+      metrics[`${prefix}.${category}.resolved`] = stat2.resolved;
+      metrics[`${prefix}.${category}.unresolved`] = stat2.unresolved;
+    }
+    return metrics;
+  }
+};
+
+// ../brain/dist/pipeline/adapters/n8n.js
+var N8nAdapter = class _N8nAdapter {
+  id = "n8n";
+  activeContextRoot = null;
+  manifest = null;
+  tracker = new ResolutionTracker(["nodes", "credentials"]);
+  resolvedNodes = /* @__PURE__ */ new Set();
+  // file rel paths
+  resolvedCredentials = /* @__PURE__ */ new Set();
+  // Structured manifest resolution: canonical node/credential name -> resolved
+  // source rel paths. This is the authoritative answer to "which file does
+  // manifest entry X point at" — the n8n gate reads this instead of guessing
+  // filenames. Built during resolveManifest().
+  nodeResolution = {};
+  credentialResolution = {};
+  // Inverse of nodeResolution: source rel path -> canonical manifest node name.
+  // Role classification keys off the CANONICAL node identity (so HttpRequest.node.ts,
+  // HttpRequestV1/2/3 all read as "HttpRequest"), not the file's own basename —
+  // which would miss version-suffixed logic files like IfV2.node.ts.
+  fileToCanonicalNode = {};
+  detect(ctx) {
+    const pkgPath = join4(ctx.projectRoot, "packages/nodes-base/package.json");
+    if (!existsSync4(pkgPath))
+      return false;
+    try {
+      const t0 = performance.now();
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+      if (!pkg.n8n)
+        return false;
+      const tParse = performance.now() - t0;
+      console.error(`[n8nAdapter] Timing: manifest parse time = ${tParse.toFixed(2)}ms`);
+      this.activeContextRoot = ctx.projectRoot;
+      this.manifest = pkg.n8n;
+      const t1 = performance.now();
+      this.resolveManifest(ctx);
+      const tResolve = performance.now() - t1;
+      console.error(`[n8nAdapter] Timing: manifest resolution time = ${tResolve.toFixed(2)}ms`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  resolveManifest(ctx) {
+    this.tracker = new ResolutionTracker(["nodes", "credentials"]);
+    this.resolvedNodes.clear();
+    this.resolvedCredentials.clear();
+    this.nodeResolution = {};
+    this.credentialResolution = {};
+    this.fileToCanonicalNode = {};
+    const nodes = this.manifest.nodes || [];
+    const credentials = this.manifest.credentials || [];
+    this.tracker.register("nodes", nodes.length);
+    this.tracker.register("credentials", credentials.length);
+    const pathRules = [
+      { pattern: /^dist\//, replacement: "packages/nodes-base/" },
+      { pattern: /\.js$/, replacement: ".ts" }
+    ];
+    const findMatches = (manifestPath) => {
+      const expectedTs = mapPath(manifestPath, pathRules);
+      const base = mapPath(basename3(manifestPath), [{ pattern: /\.js$/, replacement: ".ts" }]);
+      const baseWithoutExt = getCanonicalName(base, [/\.node\.ts$/, /\.credentials\.ts$/]);
+      const aliases = [base];
+      if (base === "HttpRequest.node.ts") {
+        aliases.push("HttpRequestV1.node.ts", "HttpRequestV2.node.ts", "HttpRequestV3.node.ts");
+      }
+      return resolveSourceFiles(ctx.files, {
+        expectedPath: expectedTs,
+        aliases,
+        versionPattern: {
+          baseName: baseWithoutExt,
+          suffix: ".node.ts"
+        },
+        filter: (rel) => rel.startsWith("packages/nodes-base/")
+      });
+    };
+    const canonicalName = (manifestPath) => getCanonicalName(manifestPath, [/\.node\.js$/, /\.credentials\.js$/]);
+    for (const n of nodes) {
+      const matches = findMatches(n);
+      const name = canonicalName(n);
+      this.nodeResolution[name] = matches;
+      if (matches.length > 0) {
+        for (const match2 of matches) {
+          this.resolvedNodes.add(match2);
+          if (!this.fileToCanonicalNode[match2])
+            this.fileToCanonicalNode[match2] = name;
+        }
+        this.tracker.resolve("nodes");
+      } else {
+        this.tracker.unresolve("nodes");
+      }
+    }
+    for (const c of credentials) {
+      const matches = findMatches(c);
+      const name = canonicalName(c);
+      this.credentialResolution[name] = matches;
+      if (matches.length > 0) {
+        for (const match2 of matches) {
+          this.resolvedCredentials.add(match2);
+        }
+        this.tracker.resolve("credentials");
+      } else {
+        this.tracker.unresolve("credentials");
+      }
+    }
+    const metrics = this.getMetrics();
+    console.error(`[n8nAdapter] Registered nodes: ${metrics["n8n.nodes.registered"]} | Resolved: ${metrics["n8n.nodes.resolved"]} | Unresolved: ${metrics["n8n.nodes.unresolved"]}`);
+    console.error(`[n8nAdapter] Registered credentials: ${metrics["n8n.credentials.registered"]} | Resolved: ${metrics["n8n.credentials.resolved"]}`);
+  }
+  getMetrics() {
+    return this.tracker.getMetrics("n8n");
+  }
+  /** Resolved source rel paths for a manifest node by canonical name (e.g. "HttpRequest").
+   *  Empty array = registered in the manifest but no source file resolved. The
+   *  n8n gate uses this so rank assertions target the real manifest-resolved
+   *  files, not filename guesses. */
+  getResolvedNode(name) {
+    return this.nodeResolution[name] ?? [];
+  }
+  /** Full manifest resolution map (canonical name -> resolved source rel paths). */
+  getNodeResolution() {
+    return this.nodeResolution;
+  }
+  getCredentialResolution() {
+    return this.credentialResolution;
+  }
+  // Behavioral execution role by CANONICAL node identity. The n8n execution
+  // BACKBONE — universal triggers/ingress, control flow, data transforms, the
+  // core HTTP protocol — is what runs in (nearly) every workflow regardless of
+  // which SaaS is wired up. The ~420 service nodes (Slack, Aws*, Google*) AND
+  // service-specific triggers (SlackTrigger) are interchangeable integration
+  // leaves: their structural size is already counted by staticGravity, so the
+  // behavioral lift gives them nothing but bare manifest membership. Only the
+  // backbone — under-rated by static because these files are tiny — is lifted.
+  static CORE_TRIGGER = /* @__PURE__ */ new Set([
+    "Webhook",
+    "ScheduleTrigger",
+    "Cron",
+    "Interval",
+    "ManualTrigger",
+    "Start",
+    "ErrorTrigger",
+    "WorkflowTrigger",
+    "ExecuteWorkflowTrigger",
+    "FormTrigger",
+    "ChatTrigger"
+  ]);
+  static CONTROL_FLOW = /* @__PURE__ */ new Set(["If", "Switch", "Merge", "Filter", "Compare", "CompareDatasets"]);
+  static DATA_TRANSFORM = /* @__PURE__ */ new Set(["Set", "Code", "Function", "FunctionItem", "RenameKeys", "ItemLists", "Aggregate", "SplitOut"]);
+  static CORE_PROTOCOL = /* @__PURE__ */ new Set(["HttpRequest", "GraphQL"]);
+  static BACKBONE_ROLES = /* @__PURE__ */ new Set(["trigger", "control_flow", "data_transform", "core_protocol"]);
+  roleForNode(canonical) {
+    if (_N8nAdapter.CORE_TRIGGER.has(canonical)) {
+      const tags2 = ["trigger_node"];
+      if (canonical === "Webhook")
+        tags2.push("ingress_boundary");
+      return { role: "trigger", tags: tags2 };
+    }
+    if (_N8nAdapter.CONTROL_FLOW.has(canonical))
+      return { role: "control_flow", tags: ["control_flow"] };
+    if (_N8nAdapter.DATA_TRANSFORM.has(canonical))
+      return { role: "data_transform", tags: ["data_transform"] };
+    if (_N8nAdapter.CORE_PROTOCOL.has(canonical))
+      return { role: "core_protocol", tags: ["core_protocol", "egress_boundary"] };
+    const tags = ["external_integration"];
+    if (canonical.endsWith("Trigger"))
+      tags.push("service_trigger", "ingress_boundary");
+    return { role: "external_integration", tags };
+  }
+  classify(ctx) {
+    const byFile = {};
+    for (const f of ctx.files) {
+      const isNode = this.resolvedNodes.has(f.rel);
+      const isCred = this.resolvedCredentials.has(f.rel);
+      if (!isNode && !isCred)
+        continue;
+      let role;
+      const tags = [];
+      if (isCred) {
+        role = "credential_handler";
+        tags.push("credential_handler");
+      } else {
+        const canonical = this.fileToCanonicalNode[f.rel] ?? basename3(f.rel).replace(/\.node\.ts$/, "");
+        const r = this.roleForNode(canonical);
+        role = r.role;
+        tags.push(...r.tags);
+        tags.push(`node:${canonical.toLowerCase()}`);
+      }
+      byFile[f.rel] = { adapterDomain: "n8n", domainTags: tags, executionRole: role };
+    }
+    return { byFile };
+  }
+  computeBehavioralLift(ctx) {
+    const t0 = performance.now();
+    const byFile = {};
+    const classifications = this.classify(ctx).byFile;
+    for (const f of ctx.files) {
+      const c = classifications[f.rel];
+      if (!c)
+        continue;
+      let lift = 0;
+      const isBackbone = c.executionRole != null && _N8nAdapter.BACKBONE_ROLES.has(c.executionRole);
+      if (this.resolvedNodes.has(f.rel)) {
+        lift += 10;
+      } else if (this.resolvedCredentials.has(f.rel)) {
+        lift += 2;
+      }
+      if (c.executionRole === "trigger")
+        lift += 35;
+      else if (c.executionRole === "control_flow")
+        lift += 45;
+      else if (c.executionRole === "data_transform")
+        lift += 40;
+      else if (c.executionRole === "core_protocol")
+        lift += 40;
+      else if (c.executionRole === "credential_handler")
+        lift += 15;
+      if (isBackbone) {
+        if (c.domainTags?.includes("ingress_boundary"))
+          lift += 15;
+        if (c.domainTags?.includes("egress_boundary"))
+          lift += 10;
+        if (f.sideEffectProfile.includes("external_api_call"))
+          lift += 8;
+        if (f.sideEffectProfile.includes("database_write"))
+          lift += 12;
+        const cxFlags = [];
+        if (f.gravitySignals?.publicSurface > 5)
+          cxFlags.push(4);
+        if (f.heatSignals?.maxNesting >= 4)
+          cxFlags.push(4);
+        if (f.heatSignals?.longFunctions > 0)
+          cxFlags.push(4);
+        if (f.gravitySignals?.loc > 500)
+          cxFlags.push(4);
+        else if (f.gravitySignals?.loc > 200)
+          cxFlags.push(2);
+        if (f.gravitySignals?.cyclomatic > 50)
+          cxFlags.push(4);
+        else if (f.gravitySignals?.cyclomatic > 20)
+          cxFlags.push(2);
+        lift += boundedSum(cxFlags, 20);
+        if (f.staticGravity > 0)
+          lift += capComponent(Math.floor(f.staticGravity / 10), 10);
+      }
+      byFile[f.rel] = lift;
+    }
+    const tLift = performance.now() - t0;
+    console.error(`[n8nAdapter] Timing: lift computation time = ${tLift.toFixed(2)}ms`);
+    return { byFile };
+  }
+};
+var n8nAdapter = new N8nAdapter();
+
+// ../brain/dist/pipeline/adapters/index.js
+adapterRegistry.register(calcomAdapter);
+adapterRegistry.register(n8nAdapter);
+
+// ../brain/dist/pipeline/classification.js
 function inferSideEffectProfile(source, importSpecs, productDomain, frameworkRole) {
   const effects = /* @__PURE__ */ new Set();
   if (/router\.(push|replace|back)\(|redirect\(|notFound\(|permanentRedirect\(/.test(source)) {
@@ -1550,22 +2360,8 @@ function inferSideEffectProfile(source, importSpecs, productDomain, frameworkRol
   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|svix|signature|req\.body|req\.rawBody/.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") || source.includes("webhook")))
-    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))
@@ -1579,37 +2375,12 @@ function inferSideEffectProfile(source, importSpecs, productDomain, frameworkRol
     effects.add("none_detected");
   return [...effects];
 }
-function inferWriteIntents(productDomain, relPath, sideEffectProfile) {
+function inferGenericWriteIntents(sideEffectProfile) {
   const intents = [];
-  if (productDomain === "booking_creation" || productDomain === "booking_ui_delegate") {
-    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"];
+  return intents;
 }
 var ENTRYPOINT_ROLES = /* @__PURE__ */ new Set([
   "app_route_page",
@@ -1634,7 +2405,7 @@ function inferRiskTypesPass1(rel, frameworkRole, productDomain, sideEffectProfil
   }
   if (productDomain === "forms" && (gravitySignals.fanIn > 3 || gravitySignals.publicSurface > 5))
     types2.push("registry_bottleneck");
-  if (sideEffectProfile.some((s) => ["booking_mutation", "payment_mutation", "auth_token_mutation"].includes(s)) && gravitySignals.cyclomatic > 10)
+  if (sideEffectProfile.some((s) => ["database_write", "trpc_mutation", "external_api_call"].includes(s)) && gravitySignals.cyclomatic > 10)
     types2.push("mutation_orchestration");
   if (ENTRYPOINT_ROLES.has(frameworkRole) && sideEffectProfile.includes("database_write")) {
     types2.push("route_handler_write_path");
@@ -1646,24 +2417,6 @@ function inferRiskTypesPass1(rel, frameworkRole, productDomain, sideEffectProfil
   }
   return types2;
 }
-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]
-  },
-  booking_ui_delegate: {
-    expected: [/book/i, /booking/i, /reschedule/i, /event-type/i, /event-types/i],
-    wrong: [/settings/i, /admin/i, /onboarding/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();
@@ -1703,12 +2456,12 @@ function findRuntimeEntrypoints(relPath, importedByMap, persisted, maxDepth = 8)
   }
   return [...byPath.values()].sort((a, b) => a.distance - b.distance);
 }
-function deriveEntrypointTraceStatus(domain, entrypoints, unresolved) {
+function deriveEntrypointTraceStatus(domain, entrypoints, unresolved, surfacePatterns = /* @__PURE__ */ new Map()) {
   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];
+  const patterns = surfacePatterns.get(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)
@@ -1716,7 +2469,7 @@ function deriveEntrypointTraceStatus(domain, entrypoints, unresolved) {
   }
   return unresolved.length === 0 ? "complete" : "partial";
 }
-function computeLoadBearingScore(gravity, heat, importedByCount, sideEffectProfile, productDomain, smellMaxSeverity, runtimeEntrypoints) {
+function computeLoadBearingScore(gravity, heat, importedByCount, sideEffectProfile, productDomain, smellMaxSeverity, runtimeEntrypoints, adapterLoadBearingBoost, domainTags) {
   let score = 0;
   if (gravity >= 85)
     score += 2;
@@ -1728,18 +2481,8 @@ function computeLoadBearingScore(gravity, heat, importedByCount, sideEffectProfi
     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 (adapterLoadBearingBoost)
+    score += adapterLoadBearingBoost;
   if (sideEffectProfile.includes("redirect"))
     score += 1;
   if (sideEffectProfile.includes("analytics_event"))
@@ -1752,14 +2495,45 @@ function computeLoadBearingScore(gravity, heat, importedByCount, sideEffectProfi
     "webhooks",
     "payments_webhooks"
   ];
-  if (highImpactDomains.includes(productDomain))
+  const effectiveDomain = domainTags?.[0] ?? productDomain;
+  if (highImpactDomains.includes(effectiveDomain))
     score += 2;
   if (smellMaxSeverity === 5)
     score += 3;
   return score;
 }
-function pageRank(nodes, outEdges, damping = 0.85, iters = 20) {
-  const n = nodes.length;
+function computeExecutionReach(nodes, importedBy, isRealSource) {
+  const rawReach = /* @__PURE__ */ new Map();
+  for (const start of nodes) {
+    const visited = /* @__PURE__ */ new Set([start]);
+    const queue = [start];
+    while (queue.length > 0) {
+      const u = queue.shift();
+      for (const v of importedBy.get(u) ?? []) {
+        if (!isRealSource.get(v) || visited.has(v))
+          continue;
+        visited.add(v);
+        queue.push(v);
+      }
+    }
+    rawReach.set(start, visited.size - 1);
+  }
+  let maxLogReach = 0;
+  const logReach = /* @__PURE__ */ new Map();
+  for (const [node, reach] of rawReach) {
+    const logR = Math.log2(1 + reach);
+    logReach.set(node, logR);
+    if (logR > maxLogReach)
+      maxLogReach = logR;
+  }
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [node, logR] of logReach) {
+    normalized.set(node, maxLogReach > 0 ? logR / maxLogReach : 0);
+  }
+  return normalized;
+}
+function pageRank(nodes, outEdges, damping = 0.85, iters = 20) {
+  const n = nodes.length;
   const rank = /* @__PURE__ */ new Map();
   if (n === 0)
     return rank;
@@ -1885,7 +2659,7 @@ function pillarNameFromCluster(files) {
     if (top)
       return titleCase(top[0]);
   }
-  const topFile = basename2(files[0].rel, extname3(files[0].rel));
+  const topFile = basename4(files[0].rel, extname3(files[0].rel));
   return titleCase(topFile);
 }
 function dirname_simple(p) {
@@ -1912,7 +2686,7 @@ function buildPillars(classified, communities) {
     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)}.`,
+      description: `${name} subsystem: ${files.length} file${files.length > 1 ? "s" : ""} centered on ${basename4(sorted[0].rel)}.`,
       memberFiles: sorted.map((f) => f.rel)
     });
   }
@@ -1938,7 +2712,7 @@ function buildPillars(classified, communities) {
       } else {
         pillars.push({
           name,
-          description: `${g.files.length} files centered on ${basename2(top[0].rel)}.`,
+          description: `${g.files.length} files centered on ${basename4(top[0].rel)}.`,
           memberFiles: top.map((f) => f.rel)
         });
       }
@@ -1959,10 +2733,10 @@ function buildPillars(classified, communities) {
       for (const rel of p.memberFiles) {
         const f = classified.find((c) => c.rel === rel);
         const role = f?.frameworkRole || "unknown";
-        const domain = f?.productDomain || "unknown";
+        const domain = f?.domainTags?.[0] ?? f?.productDomain ?? "unknown";
         let bucket;
         if (domain !== "unknown" && domain !== "routing_infrastructure" && domain !== "test_infrastructure" && domain !== "generated_noise") {
-          bucket = domainToGroupLabel(domain);
+          bucket = f?.adapterPillarLabel ?? 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)) {
@@ -2045,13 +2819,26 @@ async function runClassification(projectRoot, inv, res) {
   }
   const ranks = pageRank(realNodes, outEdges);
   const communities = detectCommunities(realNodes, undirected);
+  const executionReachByFile = computeExecutionReach(realNodes, importedBy, isRealSource);
+  const gravityV2 = process.env.VIBE_GRAVITY_V2 === "1";
+  let maxLog2FanIn = 0;
+  let maxLog2Cyclomatic = 0;
+  if (gravityV2) {
+    for (const w of work) {
+      if (!isRealSource.get(w.rel))
+        continue;
+      const fanIn = [...importedBy.get(w.rel) || []].filter((src) => isRealSource.get(src)).length;
+      maxLog2FanIn = Math.max(maxLog2FanIn, Math.log2(fanIn + 1));
+      maxLog2Cyclomatic = Math.max(maxLog2Cyclomatic, Math.log2(w.ast.cyclomatic + 1));
+    }
+  }
   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));
+    writeIntentsByFile.set(w.rel, inferGenericWriteIntents(effects));
     metaLookup.set(w.rel, { frameworkRole: w.frameworkRole, productDomain: w.productDomain });
   }
   const riskTypesByFile = /* @__PURE__ */ new Map();
@@ -2064,21 +2851,33 @@ async function runClassification(projectRoot, inv, res) {
     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 executionReach = executionReachByFile.get(w.rel) ?? 0;
     const gs = {
       fanIn,
       fanOut: fanOut.get(w.rel) || 0,
       centrality,
       cyclomatic: w.ast.cyclomatic,
       publicSurface: w.ast.publicSurface,
-      loc: w.ast.loc
+      loc: w.ast.loc,
+      executionReach
     };
-    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));
+    let gravity;
+    if (gravityV2) {
+      const fanInNorm = maxLog2FanIn > 0 ? Math.log2(fanIn + 1) / maxLog2FanIn : 0;
+      const cyclomaticNorm = maxLog2Cyclomatic > 0 ? Math.log2(w.ast.cyclomatic + 1) / maxLog2Cyclomatic : 0;
+      let gravityRaw = centrality * 0.45 + fanInNorm * 0.35 + executionReach * 0.15 + cyclomaticNorm * 0.05;
+      if (!real)
+        gravityRaw *= 0.2;
+      gravity = Math.max(0, Math.min(100, gravityRaw * 100));
+    } else {
+      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;
+      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);
@@ -2116,6 +2915,51 @@ async function runClassification(projectRoot, inv, res) {
     if (types2.length === 0)
       types2.push("complexity_hotspot");
   }
+  const adapterCtx = {
+    projectRoot,
+    files: work.map((w) => ({
+      rel: w.rel,
+      lang: w.lang,
+      isRealSource: isRealSource.get(w.rel),
+      frameworkRole: w.frameworkRole,
+      productDomain: w.productDomain,
+      staticGravity: gravityByFile.get(w.rel),
+      gravitySignals: gravitySignalsByFile.get(w.rel),
+      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
+      },
+      sideEffectProfile: sideEffectsByFile.get(w.rel),
+      importSpecs: w.importSpecs,
+      source: w.source
+    }))
+  };
+  const adapterStage = adapterRegistry.runStage(adapterCtx);
+  const surfacePatterns = /* @__PURE__ */ new Map();
+  for (const p of adapterStage.surfacePatterns) {
+    surfacePatterns.set(p.domain, { expected: p.expected, wrong: p.wrong });
+  }
+  for (const w of work) {
+    const generic = writeIntentsByFile.get(w.rel) ?? [];
+    const fromAdapter = adapterStage.writeIntentsByFile.get(w.rel) ?? [];
+    const merged = [.../* @__PURE__ */ new Set([...generic, ...fromAdapter])];
+    writeIntentsByFile.set(w.rel, merged.length > 0 ? merged : ["none_detected"]);
+  }
+  const staticGravityByFile = new Map(gravityByFile);
+  if (adapterStage.firedAdapterIds.length > 0) {
+    console.error(`[vibe-splain] adapters fired: ${adapterStage.firedAdapterIds.join(", ")}`);
+    for (const w of work) {
+      const lift = adapterStage.liftByFile.get(w.rel) ?? 0;
+      if (lift > 0) {
+        const staticGravity = gravityByFile.get(w.rel);
+        gravityByFile.set(w.rel, Math.max(staticGravity, Math.min(100, staticGravity + lift)));
+      }
+    }
+  }
   const classified = [];
   for (const w of work) {
     const real = isRealSource.get(w.rel);
@@ -2141,11 +2985,15 @@ async function runClassification(projectRoot, inv, res) {
     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 adapterCls = adapterStage.classificationByFile.get(w.rel);
+    const effectiveDomain = adapterCls?.domainTags?.[0] ?? w.productDomain;
+    const entrypointTraceStatus = deriveEntrypointTraceStatus(effectiveDomain, runtimeEntrypoints, importsUnresolvedArr, surfacePatterns);
     const smellMaxSeverity = w.ast.smells.length > 0 ? Math.max(...w.ast.smells.map((s) => s.severity)) : 0;
-    const loadBearingScore = computeLoadBearingScore(gravity, heat, fanIn, effects, w.productDomain, smellMaxSeverity, runtimeEntrypoints);
+    const loadBearingScore = computeLoadBearingScore(gravity, heat, fanIn, effects, w.productDomain, smellMaxSeverity, runtimeEntrypoints, adapterStage.loadBearingBoostByFile.get(w.rel), adapterCls?.domainTags);
     const isLoadBearing = fanIn >= 10;
     const isOperationallyCritical = loadBearingScore >= 5;
+    const staticGravity = staticGravityByFile.get(w.rel);
+    const behavioralLift = adapterStage.liftByFile.get(w.rel) ?? 0;
     classified.push({
       rel: w.rel,
       abs: w.abs,
@@ -2153,6 +3001,8 @@ async function runClassification(projectRoot, inv, res) {
       isRealSource: real,
       demoteReason: demoteReason.get(w.rel) || null,
       gravity,
+      staticGravity,
+      behavioralLift,
       heat,
       gravitySignals: gs,
       heatSignals: hs,
@@ -2173,17 +3023,22 @@ async function runClassification(projectRoot, inv, res) {
       isOperationallyCritical,
       isLoadBearing,
       hotSpans: w.ast.hotSpans,
-      source: w.source
+      source: w.source,
+      adapterDomain: adapterCls?.adapterDomain,
+      domainTags: adapterCls?.domainTags,
+      executionRole: adapterCls?.executionRole,
+      adapterSideEffects: adapterStage.sideEffectsByFile.get(w.rel),
+      adapterPillarLabel: adapterStage.pillarLabelsByFile.get(w.rel)
     });
   }
-  const dir = join4(projectRoot, ".vibe-splainer");
+  const dir = join5(projectRoot, ".vibe-splainer");
   await mkdir3(dir, { recursive: true });
   const stage05 = Object.fromEntries(classified.map((f) => [f.rel, f.sideEffectProfile]));
-  await writeFile4(join4(dir, "stage-05-side-effects.json"), JSON.stringify(stage05, null, 2), "utf8");
+  await writeFile4(join5(dir, "stage-05-side-effects.json"), JSON.stringify(stage05, null, 2), "utf8");
   const stage06 = Object.fromEntries(classified.map((f) => [f.rel, f.writeIntents]));
-  await writeFile4(join4(dir, "stage-06-write-intents.json"), JSON.stringify(stage06, null, 2), "utf8");
+  await writeFile4(join5(dir, "stage-06-write-intents.json"), JSON.stringify(stage06, null, 2), "utf8");
   const stage07 = Object.fromEntries(classified.map((f) => [f.rel, f.riskTypes]));
-  await writeFile4(join4(dir, "stage-07-risk-types.json"), JSON.stringify(stage07, null, 2), "utf8");
+  await writeFile4(join5(dir, "stage-07-risk-types.json"), JSON.stringify(stage07, null, 2), "utf8");
   const stage08 = Object.fromEntries(classified.map((f) => [f.rel, {
     isLoadBearing: f.isLoadBearing,
     isOperationallyCritical: f.isOperationallyCritical,
@@ -2191,7 +3046,7 @@ async function runClassification(projectRoot, inv, res) {
     runtimeEntrypoints: f.runtimeEntrypoints.length,
     entrypointTraceStatus: f.entrypointTraceStatus
   }]));
-  await writeFile4(join4(dir, "stage-08-load-bearing.json"), JSON.stringify(stage08, null, 2), "utf8");
+  await writeFile4(join5(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);
@@ -2205,558 +3060,32 @@ async function runClassification(projectRoot, inv, res) {
     topHeat: wildCandidates.slice(0, 12).map((f) => f.rel),
     brief: null
   };
-  return { projectRoot, classified, stack: inv.stack, entrypoints, map, communities };
-}
-
-// ../brain/dist/pipeline/binding.js
-import { join as join5 } from "path";
-import { writeFile as writeFile5, readFile as readFile4 } from "fs/promises";
-var FUNCTION_TYPES2 = /* @__PURE__ */ new Set([
-  "function_declaration",
-  "function_expression",
-  "arrow_function",
-  "method_definition",
-  "function_definition",
-  "method_declaration",
-  "func_literal",
-  "function_item",
-  "closure_expression",
-  "constructor_declaration",
-  "generator_function_declaration",
-  "generator_function"
-]);
-function firstLine2(s) {
-  return s.split("\n")[0].trim();
-}
-function walkNodes(node, cb) {
-  cb(node);
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child)
-      walkNodes(child, cb);
-  }
-}
-function resolveCallee(node) {
-  if (node.type === "identifier") {
-    return { root: node.text, prop: null };
-  }
-  if (node.type === "member_expression") {
-    const obj = node.childForFieldName("object");
-    const prop = node.childForFieldName("property");
-    if (obj && prop) {
-      const nested = resolveCallee(obj);
-      if (nested) {
-        return { root: nested.root, prop: nested.prop ? `${nested.prop}.${prop.text}` : prop.text };
-      }
-    }
-  }
-  if (node.type === "parenthesized_expression" || node.type === "await_expression") {
-    const inner = node.namedChildren.find((c) => c.type !== "(" && c.type !== ")" && c.type !== "await");
-    if (inner)
-      return resolveCallee(inner);
-  }
-  return null;
-}
-async function runActionBinding(projectRoot, inv, res) {
-  const artifact = {
-    schemaVersion: 1,
-    projectRoot,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    files: {},
-    functionIndex: {},
-    actionIndex: {},
-    entrypointIndex: {}
-  };
-  let filesProcessed = 0;
-  let functionsExtracted = 0;
-  let callsExtracted = 0;
-  let callsResolved = 0;
-  let semanticActionsExtracted = 0;
-  let entrypointsFound = 0;
-  let namedImportsExtracted = 0;
-  for (const w of inv.work) {
-    if (w.pathDemote)
-      continue;
-    filesProcessed++;
-    const filePath = w.rel;
-    const imports = [];
-    for (const raw of w.rawNamedImports) {
-      namedImportsExtracted++;
-      const { resolved, isAlias } = resolveImportWithAliasMap(raw.moduleSpecifier, w.abs, w.lang, projectRoot, inv.fileSet, inv.basenameIndex, res.aliasMap);
-      let confidence = "low";
-      if (resolved)
-        confidence = "high";
-      else if (isAlias)
-        confidence = "medium";
-      imports.push({
-        localName: raw.localName,
-        importedName: raw.importedName,
-        moduleSpecifier: raw.moduleSpecifier,
-        resolvedFilePath: resolved,
-        importKind: raw.importKind,
-        isTypeOnly: raw.isTypeOnly,
-        sourceLine: raw.sourceLine,
-        confidence,
-        evidenceText: raw.rawText.slice(0, 200)
-      });
-    }
-    const functions = [];
-    const nodeToRecord = /* @__PURE__ */ new Map();
-    if (!w.tree)
-      continue;
-    const allNodes = [];
-    walkNodes(w.tree.rootNode, (n) => {
-      allNodes.push(n);
-    });
-    for (const node of allNodes) {
-      if (!FUNCTION_TYPES2.has(node.type))
-        continue;
-      const startLine = node.startPosition.row + 1;
-      const startCol = node.startPosition.column;
-      const endLine = node.endPosition.row + 1;
-      const endCol = node.endPosition.column;
-      const isDuplicate = functions.some((f) => f.startLine === startLine && f.startCol === startCol && f.endLine === endLine && f.functionKind === node.type);
-      if (isDuplicate)
-        continue;
-      functionsExtracted++;
-      let displayName = "";
-      let nameSource = "position_fallback";
-      const p = node.parent;
-      if (node.childForFieldName("name")) {
-        displayName = node.childForFieldName("name").text;
-        nameSource = node.type === "method_definition" ? "method_definition" : "function_declaration";
-      } else if (p?.type === "variable_declarator" && p.childForFieldName("name")) {
-        displayName = p.childForFieldName("name").text;
-        nameSource = "parent_variable_declarator";
-      } else if (p?.type === "assignment_expression" && p.childForFieldName("left")) {
-        displayName = p.childForFieldName("left").text;
-        nameSource = "parent_assignment";
-      } else if (p?.type === "pair" && p.childForFieldName("key")) {
-        displayName = p.childForFieldName("key").text;
-        nameSource = "object_property_key";
-      } else if (p?.type === "export_statement") {
-        const idNode = p.children.find((c) => c.type === "identifier");
-        if (idNode) {
-          displayName = idNode.text;
-          nameSource = "export_const";
-        }
-      } else if (p?.type === "lexical_declaration" || p?.type === "variable_declaration") {
-        const decl = p.children.find((c) => c.type === "variable_declarator");
-        if (decl && decl.childForFieldName("name")) {
-          displayName = decl.childForFieldName("name").text;
-          nameSource = "parent_variable_declarator";
-        }
-      }
-      if (!displayName) {
-        displayName = `anonymous@${startLine}:${startCol}`;
-        nameSource = "position_fallback";
-      }
-      const functionId = `${filePath}::${displayName}::${startLine}:${startCol}`;
-      let isExported = false;
-      if (p?.type === "export_statement")
-        isExported = true;
-      if (p?.parent?.type === "export_statement")
-        isExported = true;
-      if (w.ast.exportedNames.includes(displayName))
-        isExported = true;
-      const isEntrypoint = (w.frameworkRole.includes("route") || w.frameworkRole.includes("page")) && isExported;
-      if (isEntrypoint)
-        entrypointsFound++;
-      const fnRecord = {
-        functionId,
-        displayName,
-        nameSource,
-        functionKind: node.type,
-        filePath,
-        startLine,
-        endLine: node.endPosition.row + 1,
-        startCol,
-        isExported,
-        isEntrypoint,
-        calls: [],
-        semanticActions: [],
-        evidenceText: firstLine2(node.text).slice(0, 200)
-      };
-      functions.push(fnRecord);
-      nodeToRecord.set(node.id, fnRecord);
-    }
-    for (const node of allNodes) {
-      if (node.type !== "call_expression" && node.type !== "call")
-        continue;
-      let curr = node.parent;
-      let containingFnRecord = null;
-      while (curr) {
-        const rec = nodeToRecord.get(curr.id);
-        if (rec) {
-          containingFnRecord = rec;
-          break;
-        }
-        curr = curr.parent;
-      }
-      if (!containingFnRecord)
-        continue;
-      callsExtracted++;
-      const calleeNode = node.childForFieldName("function") || node.namedChild(0);
-      if (!calleeNode)
-        continue;
-      const resolvedCallee = resolveCallee(calleeNode);
-      if (!resolvedCallee)
-        continue;
-      const { root: calleeRoot, prop: calleeProperty } = resolvedCallee;
-      const calleeText = calleeNode.text.slice(0, 100);
-      const sourceLine = node.startPosition.row + 1;
-      let isSemantic = false;
-      let actionKind = null;
-      let targetModel = null;
-      let targetOperation = null;
-      if (calleeRoot === "prisma" && calleeProperty) {
-        if (/\.(create|update|upsert|delete|deleteMany|updateMany|createMany|executeRaw|queryRaw)$/.test("." + calleeProperty)) {
-          isSemantic = true;
-          actionKind = "database_write";
-          const parts = calleeProperty.split(".");
-          if (parts.length >= 2) {
-            targetModel = parts[0].charAt(0).toUpperCase() + parts[0].slice(1);
-            targetOperation = parts[parts.length - 1];
-          }
-        } else if (/\.(findMany|findUnique|findFirst|findFirstOrThrow|findUniqueOrThrow|count|aggregate|groupBy)$/.test("." + calleeProperty)) {
-          isSemantic = true;
-          actionKind = "database_read";
-          const parts = calleeProperty.split(".");
-          if (parts.length >= 2) {
-            targetModel = parts[0].charAt(0).toUpperCase() + parts[0].slice(1);
-            targetOperation = parts[parts.length - 1];
-          }
-        }
-      } else if (calleeRoot === "trpc" && calleeProperty && /\.(useMutation|mutate|mutateAsync)$/.test("." + calleeProperty)) {
-        isSemantic = true;
-        actionKind = "external_api_call";
-        const parts = calleeProperty.split(".");
-        if (parts.length >= 2) {
-          targetModel = parts[0];
-          targetOperation = parts[parts.length - 1];
-        }
-      }
-      if (!isSemantic) {
-        if (calleeRoot === "fetch" || calleeRoot === "axios" && calleeProperty && /\.(get|post|put|patch|delete)$/.test("." + calleeProperty)) {
-          isSemantic = true;
-          actionKind = "external_api_call";
-        } else if (/validate|schema\.parse|schema\.safeParse|z\.parse/i.test(calleeText) || /validate|validator/i.test(calleeRoot)) {
-          isSemantic = true;
-          actionKind = "validation";
-        } else if (/getSession|getServerSession|auth\(\)|verifyToken|requireAuth|checkPermission/i.test(calleeText) || /auth|session/i.test(calleeRoot) && calleeProperty && /check|verify|get|require/i.test("." + calleeProperty)) {
-          isSemantic = true;
-          actionKind = "auth_check";
-        } else if (/sendEmail|sendMail|mailer\./i.test(calleeText)) {
-          isSemantic = true;
-          actionKind = "email_send";
-        } else if (/createCalendarEvent|updateCalendarEvent|deleteCalendarEvent|calendar\.events\.(insert|update|delete)/i.test(calleeText)) {
-          isSemantic = true;
-          actionKind = "calendar_mutation";
-        } else if (/triggerWebhook|sendWebhook|webhook\.send/i.test(calleeText)) {
-          isSemantic = true;
-          actionKind = "webhook_delivery";
-        } else if (/stripe\.webhooks\.constructEvent|validateWebhook|verifySignature/i.test(calleeText)) {
-          isSemantic = true;
-          actionKind = "webhook_ingress";
-        } else if (/revalidatePath|revalidateTag/i.test(calleeText)) {
-          isSemantic = true;
-          actionKind = "cache_revalidation";
-        } else if (/posthog\.|mixpanel\.|amplitude\.|ga\(/i.test(calleeText)) {
-          isSemantic = true;
-          actionKind = "analytics_event";
-        } else if (calleeRoot === "redirect" || /router|redirect|notFound|permanentRedirect/.test(calleeRoot) && calleeProperty && /push|replace|back/i.test("." + calleeProperty)) {
-          isSemantic = true;
-          actionKind = "redirect";
-        } else if (/cookies\(\)|headers\(\)/.test(calleeText) || calleeRoot === "cookies" || calleeRoot === "headers") {
-          isSemantic = true;
-          actionKind = "side_effect";
-        } else if (/checkRateLimitAndThrowError/i.test(calleeText)) {
-          isSemantic = true;
-          actionKind = "auth_check";
-        } else {
-          const emailImport = imports.find((i) => i.localName === calleeRoot && /nodemailer|resend|sendgrid|postmark|mailgun/i.test(i.moduleSpecifier));
-          if (emailImport) {
-            isSemantic = true;
-            actionKind = "email_send";
-          }
-        }
-      }
-      if (isSemantic && actionKind) {
-        semanticActionsExtracted++;
-        const actionId = `${containingFnRecord.functionId}::${actionKind}::${sourceLine}`;
-        containingFnRecord.semanticActions.push({
-          actionId,
-          sourceFunctionId: containingFnRecord.functionId,
-          actionKind,
-          targetModel,
-          targetOperation,
-          calleeText,
-          sourceLine,
-          confidence: "high",
-          evidenceText: firstLine2(node.text).slice(0, 200)
-        });
-        if (!artifact.actionIndex[actionKind])
-          artifact.actionIndex[actionKind] = [];
-        artifact.actionIndex[actionKind].push(containingFnRecord.functionId);
-        if (targetModel) {
-          const key1 = `${actionKind}::${targetModel}`;
-          if (!artifact.actionIndex[key1])
-            artifact.actionIndex[key1] = [];
-          artifact.actionIndex[key1].push(containingFnRecord.functionId);
-          if (targetOperation) {
-            const key2 = `${actionKind}::${targetModel}::${targetOperation}`;
-            if (!artifact.actionIndex[key2])
-              artifact.actionIndex[key2] = [];
-            artifact.actionIndex[key2].push(containingFnRecord.functionId);
-          }
-        }
-      } else {
-        let resolvedTargetFunctionId = null;
-        let resolvedFilePath = null;
-        let resolutionKind = "unresolved";
-        let confidence = "unresolved";
-        const sameFileFn = functions.find((f) => f.displayName === calleeRoot);
-        if (sameFileFn) {
-          resolvedTargetFunctionId = sameFileFn.functionId;
-          resolutionKind = "same_file_function";
-          confidence = "high";
-        } else {
-          const namedImp = imports.find((i) => i.localName === calleeRoot && i.importKind !== "namespace" && !i.isTypeOnly);
-          if (namedImp && namedImp.resolvedFilePath) {
-            resolvedFilePath = namedImp.resolvedFilePath;
-            resolutionKind = "named_import_match";
-            confidence = "high";
-          } else {
-            const nsImp = imports.find((i) => i.localName === calleeRoot && i.importKind === "namespace");
-            if (nsImp && nsImp.resolvedFilePath) {
-              resolvedFilePath = nsImp.resolvedFilePath;
-              resolutionKind = "namespace_import_property";
-              confidence = "medium";
-            }
-          }
-        }
-        if (resolutionKind !== "unresolved")
-          callsResolved++;
-        containingFnRecord.calls.push({
-          callId: `${containingFnRecord.functionId}::${calleeText}::${sourceLine}`,
-          sourceFunctionId: containingFnRecord.functionId,
-          calleeText,
-          calleeRoot,
-          calleeProperty,
-          sourceLine,
-          sourceSpan: { startLine: node.startPosition.row + 1, endLine: node.endPosition.row + 1 },
-          resolvedTargetFunctionId,
-          resolvedFilePath,
-          resolutionKind,
-          confidence,
-          evidenceText: firstLine2(node.text).slice(0, 200)
-        });
-      }
-    }
-    artifact.files[filePath] = {
-      filePath,
-      language: w.lang,
-      sourceRole: w.frameworkRole === "test" ? "test" : "production",
-      imports,
-      functions
-    };
-    for (const fn of functions) {
-      artifact.functionIndex[fn.functionId] = {
-        filePath,
-        displayName: fn.displayName,
-        startLine: fn.startLine,
-        endLine: fn.endLine
-      };
-      if (fn.isEntrypoint) {
-        if (!artifact.entrypointIndex[filePath])
-          artifact.entrypointIndex[filePath] = [];
-        artifact.entrypointIndex[filePath].push(fn.functionId);
-      }
-    }
-  }
-  for (const fileRec of Object.values(artifact.files)) {
-    for (const fnRec of fileRec.functions) {
-      for (const callRec of fnRec.calls) {
-        if (callRec.resolvedTargetFunctionId)
-          continue;
-        if (!callRec.resolvedFilePath)
-          continue;
-        const targetFile = artifact.files[callRec.resolvedFilePath];
-        if (!targetFile)
-          continue;
-        if (callRec.resolutionKind === "named_import_match") {
-          const targetFn = targetFile.functions.find((f) => f.displayName === callRec.calleeRoot && f.isExported);
-          if (targetFn) {
-            callRec.resolvedTargetFunctionId = targetFn.functionId;
-            callRec.confidence = "high";
-          }
-        } else if (callRec.resolutionKind === "namespace_import_property" && callRec.calleeProperty) {
-          const targetFn = targetFile.functions.find((f) => f.displayName === callRec.calleeProperty && f.isExported);
-          if (targetFn) {
-            callRec.resolvedTargetFunctionId = targetFn.functionId;
-            callRec.confidence = "high";
-          }
-        } else if (callRec.resolutionKind === "namespace_import_property" && !callRec.calleeProperty) {
-          const defaultFn = targetFile.functions.find((f) => f.displayName === "default");
-          if (defaultFn) {
-            callRec.resolvedTargetFunctionId = defaultFn.functionId;
-            callRec.confidence = "high";
-          }
-        }
-      }
-    }
-  }
-  await writeFile5(join5(projectRoot, ".vibe-splainer", "action_bindings.json"), JSON.stringify(artifact, null, 2), "utf8");
-  const summary = {
-    filesProcessed,
-    functionsExtracted,
-    callsExtracted,
-    callsResolved,
-    semanticActionsExtracted,
-    entrypointsFound,
-    namedImportsExtracted
-  };
-  await writeFile5(join5(projectRoot, ".vibe-splainer", "stage-09-action-bindings-summary.json"), JSON.stringify(summary, null, 2), "utf8");
-  return { artifact };
-}
-async function traverseCallChain(projectRoot, args) {
-  const artifactPath = join5(projectRoot, ".vibe-splainer", "action_bindings.json");
-  let artifact;
-  try {
-    const raw = await readFile4(artifactPath, "utf8");
-    artifact = JSON.parse(raw);
-  } catch {
-    throw new Error("action_bindings.json not found. Run scan_project first.");
-  }
-  const { entrypointPath, maxDepth = 6, targetActionKind, targetModel, targetOperation, targetFunctionName, includeTests = false } = args;
-  let seedFunctionIds = [];
-  if (artifact.entrypointIndex[entrypointPath]) {
-    seedFunctionIds = artifact.entrypointIndex[entrypointPath];
-  } else if (artifact.files[entrypointPath]) {
-    const fileRec = artifact.files[entrypointPath];
-    seedFunctionIds = fileRec.functions.filter((f) => f.isEntrypoint).map((f) => f.functionId);
-    if (seedFunctionIds.length === 0) {
-      const firstExported = fileRec.functions.find((f) => f.isExported);
-      if (firstExported)
-        seedFunctionIds.push(firstExported.functionId);
-    }
-  }
-  if (seedFunctionIds.length === 0) {
-    throw new Error(`No entrypoint functions found in ${entrypointPath}`);
-  }
-  const chain = [];
-  const unresolvedEdges = [];
-  const visited = /* @__PURE__ */ new Set();
-  const queue = seedFunctionIds.map((id) => ({ functionId: id, callerFunctionId: null, depth: 0 }));
-  let targetReached = false;
-  let truncatedAtDepth = false;
-  while (queue.length > 0) {
-    const { functionId, callerFunctionId, depth, callsite } = queue.shift();
-    const visitKey = `${callerFunctionId}->${functionId}`;
-    if (visited.has(visitKey))
-      continue;
-    visited.add(visitKey);
-    const indexEntry = artifact.functionIndex[functionId];
-    if (!indexEntry)
-      continue;
-    const fileRec = artifact.files[indexEntry.filePath];
-    if (!fileRec)
-      continue;
-    if (!includeTests && fileRec.sourceRole === "test")
-      continue;
-    const fnRec = fileRec.functions.find((f) => f.functionId === functionId);
-    if (!fnRec)
-      continue;
-    let isTarget = false;
-    if (targetFunctionName && fnRec.displayName === targetFunctionName)
-      isTarget = true;
-    if (isTarget)
-      targetReached = true;
-    chain.push({
-      functionId,
-      callerFunctionId,
-      displayName: fnRec.displayName,
-      filePath: fnRec.filePath,
-      startLine: fnRec.startLine,
-      edgeKind: "call_edge",
-      confidence: "high",
-      evidenceText: fnRec.evidenceText,
-      isTarget,
-      depth,
-      callsite
-    });
-    for (const action of fnRec.semanticActions) {
-      let isActionTarget = false;
-      if (targetActionKind && action.actionKind === targetActionKind) {
-        isActionTarget = true;
-        if (targetModel && action.targetModel !== targetModel)
-          isActionTarget = false;
-        if (targetOperation && action.targetOperation !== targetOperation)
-          isActionTarget = false;
-      } else if (targetModel && action.targetModel === targetModel) {
-        isActionTarget = true;
-        if (targetOperation && action.targetOperation !== targetOperation)
-          isActionTarget = false;
-      }
-      if (isActionTarget)
-        targetReached = true;
-      chain.push({
-        functionId: action.actionId,
-        callerFunctionId: functionId,
-        displayName: action.calleeText,
-        filePath: fileRec.filePath,
-        startLine: action.sourceLine,
-        edgeKind: "semantic_action",
-        actionKind: action.actionKind,
-        targetModel: action.targetModel || void 0,
-        targetOperation: action.targetOperation || void 0,
-        confidence: action.confidence,
-        evidenceText: action.evidenceText,
-        isTarget: isActionTarget,
-        depth: depth + 1
-      });
-    }
-    if (depth < maxDepth) {
-      for (const call of fnRec.calls) {
-        if (call.resolvedTargetFunctionId) {
-          queue.push({
-            functionId: call.resolvedTargetFunctionId,
-            callerFunctionId: functionId,
-            depth: depth + 1,
-            callsite: {
-              file: fileRec.filePath,
-              line: call.sourceLine,
-              text: call.calleeText
-            }
-          });
-        } else {
-          unresolvedEdges.push({
-            fromFunctionId: functionId,
-            calleeText: call.calleeText,
-            sourceLine: call.sourceLine,
-            reason: call.resolutionKind
-          });
-        }
-      }
-    } else if (fnRec.calls.length > 0) {
-      truncatedAtDepth = true;
-    }
-  }
-  return {
-    targetReached,
-    truncatedAtDepth,
-    chain,
-    unresolvedEdges
-  };
+  return { projectRoot, classified, stack: inv.stack, entrypoints, map, communities, adapterStage };
 }
 
 // ../brain/dist/pipeline/scoring.js
 import { join as join6 } from "path";
-import { mkdir as mkdir4, readFile as readFile5 } from "fs/promises";
-function computeSeverity(sideEffectProfile, productDomain, gravity, heat, maxNesting, hasLongFunctions, swallowedCatches, runtimeEntrypoints) {
+import { mkdir as mkdir4 } from "fs/promises";
+function genericSeverityScore(sideEffectProfile, gravity, heat, maxNesting, hasLongFunctions, swallowedCatches, runtimeEntrypoints) {
   let score = 0;
   if (sideEffectProfile.includes("database_write"))
     score += 3;
+  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;
+  return score;
+}
+function calcomDomainSeverityScore(sideEffectProfile, productDomain) {
+  let score = 0;
   if (sideEffectProfile.includes("booking_mutation"))
     score += 4;
   if (sideEffectProfile.includes("payment_mutation"))
@@ -2777,18 +3106,12 @@ function computeSeverity(sideEffectProfile, productDomain, gravity, heat, maxNes
     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;
+  return score;
+}
+function computeSeverity(sideEffectProfile, productDomain, gravity, heat, maxNesting, hasLongFunctions, swallowedCatches, runtimeEntrypoints, adapterSeverityContribution, adapterSideEffects) {
+  const effs = Array.from(/* @__PURE__ */ new Set([...sideEffectProfile, ...adapterSideEffects || []]));
+  const domainScore = adapterSeverityContribution ?? calcomDomainSeverityScore(effs, productDomain);
+  const score = genericSeverityScore(effs, gravity, heat, maxNesting, hasLongFunctions, swallowedCatches, runtimeEntrypoints) + domainScore;
   if (score >= 10)
     return 5;
   if (score >= 7)
@@ -2801,13 +3124,16 @@ function computeSeverity(sideEffectProfile, productDomain, gravity, heat, maxNes
 }
 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");
+    if (!file.adapterSideEffects)
+      file.adapterSideEffects = [];
+    if (!file.adapterSideEffects.includes("payment_mutation"))
+      file.adapterSideEffects.push("payment_mutation");
+    if (!file.adapterSideEffects.includes("webhook_ingress"))
+      file.adapterSideEffects.push("webhook_ingress");
     file.sideEffectProfile = file.sideEffectProfile.filter((s) => s !== "none_detected");
   }
-  if (file.sideEffectProfile.includes("payment_mutation") || file.sideEffectProfile.includes("booking_mutation")) {
+  const adapterEffects = file.adapterSideEffects || [];
+  if (adapterEffects.includes("payment_mutation") || adapterEffects.includes("booking_mutation")) {
     if (file.canonicalSeverity < 4)
       file.canonicalSeverity = 4;
   }
@@ -2826,21 +3152,28 @@ function deriveConfidence(fanIn, gravity) {
     return "medium";
   return "low";
 }
-async function runScoring(projectRoot, cr, binding) {
+async function runScoring(projectRoot, cr) {
   const dir = join6(projectRoot, ".vibe-splainer");
   await mkdir4(dir, { recursive: true });
-  let bindingArtifact = binding?.artifact;
-  if (!bindingArtifact) {
-    try {
-      const raw = await readFile5(join6(projectRoot, ".vibe-splainer", "action_bindings.json"), "utf8");
-      bindingArtifact = JSON.parse(raw);
-    } catch {
-    }
-  }
   const persisted = {};
   const severityBreakdowns = {};
+  const adapterFired = cr.adapterStage.firedAdapterIds.length > 0;
+  let sevBridgeChecked = 0;
+  let sevBridgeMismatch = 0;
   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 adapterDomainScore = cr.adapterStage.severityBoostByFile.get(f.rel);
+    const effectiveDomain = f.domainTags?.[0] ?? f.adapterDomain ?? f.productDomain;
+    const severity = computeSeverity(f.sideEffectProfile, effectiveDomain, f.gravity, f.heat, f.heatSignals.maxNesting, f.heatSignals.longFunctions > 0, f.heatSignals.swallowedCatches, f.runtimeEntrypoints, adapterDomainScore, f.adapterSideEffects);
+    if (adapterFired) {
+      const effs = [...f.sideEffectProfile, ...f.adapterSideEffects || []];
+      const coreDomainScore = calcomDomainSeverityScore(effs, f.productDomain);
+      const adapterScore = adapterDomainScore ?? 0;
+      if (coreDomainScore > 0 || adapterScore > 0) {
+        sevBridgeChecked++;
+        if (coreDomainScore !== adapterScore)
+          sevBridgeMismatch++;
+      }
+    }
     const confidence = deriveConfidence(f.gravitySignals.fanIn, f.gravity);
     const pf = {
       relativePath: f.rel,
@@ -2848,6 +3181,8 @@ async function runScoring(projectRoot, cr, binding) {
       isRealSource: f.isRealSource,
       demoteReason: f.demoteReason,
       gravity: Math.round(f.gravity),
+      staticGravity: Math.round(f.staticGravity),
+      behavioralLift: Math.round(f.behavioralLift),
       heat: Math.round(f.heat),
       gravitySignals: f.gravitySignals,
       heatSignals: f.heatSignals,
@@ -2869,22 +3204,28 @@ async function runScoring(projectRoot, cr, binding) {
       // STRICT: fanIn >= 10
       isOperationallyCritical: f.isOperationallyCritical,
       confidence,
-      source: f.source
+      source: f.source,
+      adapterDomain: f.adapterDomain,
+      domainTags: f.domainTags,
+      executionRole: f.executionRole,
+      adapterSideEffects: f.adapterSideEffects,
+      adapterSeverityContribution: adapterDomainScore,
+      // parallel; not applied yet
+      adapterPillarLabel: f.adapterPillarLabel
     };
     applyCorrections(pf);
     persisted[f.rel] = pf;
     severityBreakdowns[f.rel] = `severity=${pf.canonicalSeverity} loadBearing=${pf.canonicalLoadBearing} effects=${pf.sideEffectProfile.join(",")} domain=${pf.productDomain}`;
   }
-  const deltaTargets = Object.values(persisted).filter((pf) => pf.isRealSource).sort((a, b) => b.gravity - a.gravity).map((pf) => ({
-    path: pf.relativePath,
-    gravity: Math.round(pf.gravity),
-    isLoadBearing: pf.canonicalLoadBearing,
-    // STRICT: fanIn >= 10
-    blastRadius: pf.importedBy,
-    pillarHint: pf.pillarHint
-  }));
-  const store = { files: persisted };
-  const validationReport = await buildValidationReport(store, deltaTargets, projectRoot, cr);
+  if (adapterFired) {
+    console.error(`[vibe-splain] severity bridge: ${sevBridgeChecked - sevBridgeMismatch}/${sevBridgeChecked} Cal.com domain contributions match core (${sevBridgeMismatch} mismatch)`);
+  }
+  const store = {
+    files: persisted,
+    adapterFired: cr.adapterStage.firedAdapterIds,
+    adapterMetrics: cr.adapterStage.metrics
+  };
+  const validationReport = await buildValidationReport(store, projectRoot, cr);
   store.validationReport = validationReport;
   for (const e of validationReport.errors) {
     console.error(`[vibe-splain] VALIDATION ERROR [${e.rule}] ${e.file}: ${e.detail}`);
@@ -2892,9 +3233,9 @@ async function runScoring(projectRoot, cr, binding) {
   for (const w of validationReport.warnings) {
     console.error(`[vibe-splain] VALIDATION WARN [${w.rule}] ${w.file}: ${w.detail}`);
   }
-  return { store, deltaTargets, validationReport };
+  return { store, validationReport };
 }
-async function buildValidationReport(store, deltaTargets, projectRoot, cr) {
+async function buildValidationReport(store, projectRoot, cr) {
   const errors = [];
   const warnings = [];
   let passCount = 0;
@@ -2926,7 +3267,7 @@ async function buildValidationReport(store, deltaTargets, projectRoot, cr) {
       });
       continue;
     }
-    if (pf.productDomain === "booking_creation" && classified?.entrypointTraceStatus === "no_runtime_entrypoint_found" && pf.importsUnresolved.length === 0 && !["app_route_layout", "app_loading_boundary", "app_error_boundary"].includes(pf.frameworkRole) && (pf.sideEffectProfile.includes("booking_mutation") || pf.source.includes("createBooking") || pf.source.includes("handleNewBooking"))) {
+    if (pf.productDomain === "booking_creation" && classified?.entrypointTraceStatus === "no_runtime_entrypoint_found" && pf.importsUnresolved.length === 0 && !["app_route_layout", "app_loading_boundary", "app_error_boundary"].includes(pf.frameworkRole) && (pf.adapterSideEffects?.includes("booking_mutation") || pf.source.includes("createBooking") || pf.source.includes("handleNewBooking"))) {
       errors.push({
         file: pf.relativePath,
         rule: "booking_creation_no_entrypoint_no_blockers",
@@ -2964,7 +3305,7 @@ async function buildValidationReport(store, deltaTargets, projectRoot, cr) {
     if (!pf.isRealSource)
       continue;
     const hasIntent = pf.writeIntents.includes("handle_payment_webhook");
-    const hasWebhookIngress = pf.sideEffectProfile.includes("webhook_ingress");
+    const hasWebhookIngress = pf.adapterSideEffects?.includes("webhook_ingress");
     const pathMentionsPayment = PAYMENT_PROVIDER_PATH_TERMS.some((t) => rel.toLowerCase().includes(t));
     if (!hasIntent && !(hasWebhookIngress && pathMentionsPayment && pf.frameworkRole !== "component"))
       continue;
@@ -2975,12 +3316,12 @@ async function buildValidationReport(store, deltaTargets, projectRoot, cr) {
         `Payment webhook not classified as payments_webhooks`
       ],
       [
-        !pf.sideEffectProfile.includes("webhook_ingress"),
+        !pf.adapterSideEffects?.includes("webhook_ingress"),
         "webhook_ingress_missing",
         `Payment webhook missing webhook_ingress side effect`
       ],
       [
-        !pf.sideEffectProfile.includes("payment_mutation"),
+        !pf.adapterSideEffects?.includes("payment_mutation"),
         "webhook_payment_mutation_missing",
         `Payment webhook missing payment_mutation side effect`
       ],
@@ -3023,9 +3364,8 @@ async function buildValidationReport(store, deltaTargets, projectRoot, cr) {
 async function runPipeline(projectRoot) {
   const inv = await runInventory(projectRoot);
   const res = await runResolution(projectRoot, inv);
-  const binding = await runActionBinding(projectRoot, inv, res);
   const cr = await runClassification(projectRoot, inv, res);
-  const scoring = await runScoring(projectRoot, cr, binding);
+  const scoring = await runScoring(projectRoot, cr);
   const files = cr.classified.filter((f) => f.isRealSource).sort((a, b) => b.gravity - a.gravity).map((f) => ({
     path: f.abs,
     relativePath: f.rel,
@@ -3038,9 +3378,9 @@ async function runPipeline(projectRoot) {
     heatSignals: f.heatSignals,
     smells: f.smells,
     pillarHint: f.pillarHint,
-    frameworkRole: f.frameworkRole,
-    productDomain: f.productDomain,
-    sideEffectProfile: f.sideEffectProfile
+    frameworkRole: f.executionRole ?? f.frameworkRole,
+    productDomain: f.domainTags?.[0] ?? f.adapterDomain ?? f.productDomain,
+    sideEffectProfile: f.adapterSideEffects ?? 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,
@@ -3054,9 +3394,9 @@ async function runPipeline(projectRoot) {
     heatSignals: f.heatSignals,
     smells: f.smells,
     pillarHint: f.pillarHint,
-    frameworkRole: f.frameworkRole,
-    productDomain: f.productDomain,
-    sideEffectProfile: f.sideEffectProfile
+    frameworkRole: f.executionRole ?? f.frameworkRole,
+    productDomain: f.domainTags?.[0] ?? f.adapterDomain ?? f.productDomain,
+    sideEffectProfile: f.adapterSideEffects ?? f.sideEffectProfile
   }));
   const uiUrl = `file://${join7(projectRoot, ".vibe-splainer", "ui", "index.html")}`;
   return {
@@ -3093,7 +3433,7 @@ async function getFileAnalysis(absPath) {
     return null;
   let source;
   try {
-    source = await readFile6(absPath, "utf8");
+    source = await readFile4(absPath, "utf8");
   } catch {
     return null;
   }
@@ -3132,20 +3472,11 @@ async function getFileAnalysis(absPath) {
 
 // ../brain/dist/analysis.js
 import { join as join8 } from "path";
-import { readFile as readFile7, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
+import { readFile as readFile5, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
 async function readAnalysis(projectRoot) {
   const p = join8(projectRoot, ".vibe-splainer", "analysis.json");
   try {
-    const raw = await readFile7(p, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-async function readActionBindings(projectRoot) {
-  const p = join8(projectRoot, ".vibe-splainer", "action_bindings.json");
-  try {
-    const raw = await readFile7(p, "utf8");
+    const raw = await readFile5(p, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -3154,11 +3485,11 @@ async function readActionBindings(projectRoot) {
 
 // ../brain/dist/dossier.js
 import { join as join9 } from "path";
-import { readFile as readFile8 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 async function readDossier(projectRoot) {
   const dossierPath = join9(projectRoot, ".vibe-splainer", "dossier.json");
   try {
-    const raw = await readFile8(dossierPath, "utf8");
+    const raw = await readFile6(dossierPath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -3262,93 +3593,1141 @@ var RecommendationEngine = class {
   }
 };
 
-// ../brain/dist/ProofValidator.js
-import { createHash } from "crypto";
-import { readFile as readFile9 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-var ProofValidator = class {
-  /**
-   * Full validation of a WorkerReceipt against a Work Order's required proofs.
-   * Checks all 8 required conditions from the spec.
-   *
-   * @param receipt - The WorkerReceipt to validate
-   * @param requiredProof - Proof descriptors from the Work Order
-   * @param isAllowedFile - Predicate built by the CLI layer (handles globs/allowedFiles)
-   * @param blobDir - Path to .vibe-splainer/blobs/
-   */
-  static async validate(receipt, requiredProof, isAllowedFile, blobDir) {
-    const errors = [];
-    const warnings = [];
-    for (const req of requiredProof) {
-      const found = receipt.proofPointers.find((p) => p.schemaName === req.schemaName || p.pointer.includes(req.proofId));
-      if (!found) {
-        errors.push(`MissingProof: required proof "${req.proofId}" (schema: ${req.schemaName}) not in receipt`);
+// ../brain/dist/network/specialists.js
+var SPECIALIST_REGISTRY = {
+  control_flow: {
+    id: "control_flow",
+    label: "Control Flow",
+    description: "Codebase expert for branching, merging, looping, and execution routing.",
+    owns: [
+      "IF",
+      "Merge",
+      "Switch",
+      "SplitInBatches",
+      "LoopOverItems",
+      "Wait",
+      "ExecuteWorkflow",
+      "ErrorTrigger",
+      "StopAndError",
+      "NoOp",
+      "branching",
+      "conditions",
+      "execution routing",
+      "workflow orchestration",
+      "connection structure"
+    ],
+    canCommentOn: [
+      "branch evaluation",
+      "merge semantics",
+      "loop iteration",
+      "connection path",
+      "wrong source port",
+      "execution path"
+    ],
+    mustNotCommentOn: [
+      "external API credentials",
+      "Slack schema details",
+      "Gmail auth details",
+      "database credential setup",
+      "HTTP response body shape unless handed off by data_transform"
+    ],
+    handoffTriggers: ["data_transform", "integration_contracts"],
+    allowedOutputFields: [
+      "faultHypothesis",
+      "recommendedLocalChange",
+      "filesToEdit",
+      "filesToAvoid",
+      "mustNotChange",
+      "evidence",
+      "confidence",
+      "handoffTo"
+    ],
+    forbiddenOutputFields: ["contractObserved", "contractExpected"],
+    keywords: [
+      "if",
+      "branch",
+      "condition",
+      "merge",
+      "loop",
+      "switch",
+      "split",
+      "wait",
+      "connection",
+      "edge",
+      "route",
+      "routing",
+      "source port",
+      "execution path"
+    ],
+    nodeTypes: [
+      "n8n-nodes-base.if",
+      "n8n-nodes-base.merge",
+      "n8n-nodes-base.switch",
+      "n8n-nodes-base.splitInBatches",
+      "n8n-nodes-base.loopOverItems",
+      "n8n-nodes-base.wait",
+      "n8n-nodes-base.executeWorkflow",
+      "n8n-nodes-base.errorTrigger",
+      "n8n-nodes-base.stopAndError",
+      "n8n-nodes-base.noOp"
+    ]
+  },
+  data_transform: {
+    id: "data_transform",
+    label: "Data Transformation + HTTP",
+    description: "Codebase expert for payload manipulation, HTTP request/response contracts, and expressions.",
+    owns: [
+      "HttpRequest",
+      "Set",
+      "Code",
+      "Function",
+      "ItemLists",
+      "DateTime",
+      "Crypto",
+      "MoveBinaryData",
+      "EditFields",
+      "RespondToWebhook",
+      "Aggregate",
+      "Summarize",
+      "payload mapping",
+      "JSON path",
+      "expression path",
+      "item arrays",
+      "binary versus JSON handling",
+      "HTTP request and response shape"
+    ],
+    canCommentOn: [
+      "field paths",
+      "response body shape",
+      "item array transformations",
+      "expression syntax",
+      "schema mapping"
+    ],
+    mustNotCommentOn: [
+      "credential configuration",
+      "auth mode selection",
+      "external service permissions",
+      "branching semantics unless handed off by control_flow"
+    ],
+    handoffTriggers: ["control_flow", "integration_contracts"],
+    allowedOutputFields: [
+      "faultHypothesis",
+      "contractObserved",
+      "contractExpected",
+      "recommendedLocalChange",
+      "filesToEdit",
+      "filesToAvoid",
+      "mustNotChange",
+      "evidence",
+      "confidence",
+      "handoffTo"
+    ],
+    forbiddenOutputFields: [],
+    keywords: [
+      "http",
+      "httprequest",
+      "payload",
+      "json",
+      "expression",
+      "path",
+      "field",
+      "schema",
+      "body",
+      "response",
+      "set",
+      "code",
+      "item",
+      "items",
+      "array",
+      "binary",
+      "mapping",
+      "transform"
+    ],
+    nodeTypes: [
+      "n8n-nodes-base.httpRequest",
+      "n8n-nodes-base.set",
+      "n8n-nodes-base.code",
+      "n8n-nodes-base.function",
+      "n8n-nodes-base.itemLists",
+      "n8n-nodes-base.dateTime",
+      "n8n-nodes-base.crypto",
+      "n8n-nodes-base.moveBinaryData",
+      "n8n-nodes-base.editFields",
+      "n8n-nodes-base.respondToWebhook",
+      "n8n-nodes-base.aggregate",
+      "n8n-nodes-base.summarize"
+    ]
+  },
+  integration_contracts: {
+    id: "integration_contracts",
+    label: "Integration Contracts",
+    description: "Codebase expert for external service contracts, authentication patterns, and API integrations.",
+    owns: [
+      "Slack",
+      "Gmail",
+      "GoogleSheets",
+      "Postgres",
+      "S3",
+      "Notion",
+      "Airtable",
+      "Discord",
+      "Webhook",
+      "GitHub",
+      "Jira",
+      "HubSpot",
+      "external API contracts",
+      "credentials",
+      "auth behavior",
+      "rate limiting",
+      "pagination",
+      "integration node input and output expectations",
+      "external service side effects"
+    ],
+    canCommentOn: [
+      "external service contract",
+      "credential usage",
+      "auth mode",
+      "API response expectations",
+      "integration node input requirements",
+      "downstream service behavior"
+    ],
+    mustNotCommentOn: [
+      "generic branch logic",
+      "internal item transformation mechanics",
+      "unrelated workflow nodes",
+      "global workflow architecture"
+    ],
+    handoffTriggers: ["data_transform", "control_flow"],
+    allowedOutputFields: [
+      "faultHypothesis",
+      "contractObserved",
+      "contractExpected",
+      "recommendedLocalChange",
+      "filesToEdit",
+      "filesToAvoid",
+      "mustNotChange",
+      "evidence",
+      "confidence",
+      "handoffTo"
+    ],
+    forbiddenOutputFields: [],
+    keywords: [
+      "slack",
+      "gmail",
+      "webhook",
+      "postgres",
+      "notion",
+      "github",
+      "jira",
+      "hubspot",
+      "s3",
+      "api",
+      "credential",
+      "credentials",
+      "auth",
+      "oauth",
+      "token",
+      "external",
+      "service",
+      "rate limit",
+      "pagination",
+      "contract"
+    ],
+    nodeTypes: [
+      "n8n-nodes-base.slack",
+      "n8n-nodes-base.gmail",
+      "n8n-nodes-base.googleSheets",
+      "n8n-nodes-base.postgres",
+      "n8n-nodes-base.s3",
+      "n8n-nodes-base.notion",
+      "n8n-nodes-base.airtable",
+      "n8n-nodes-base.discord",
+      "n8n-nodes-base.webhook",
+      "n8n-nodes-base.github",
+      "n8n-nodes-base.jira",
+      "n8n-nodes-base.hubspot"
+    ]
+  },
+  generic_repo: {
+    id: "generic_repo",
+    label: "Generic Repository Fallback",
+    description: "Fallback expert for generic static analysis, non-adapter repos, and general tasks.",
+    owns: [
+      "fallback routing",
+      "unknown tasks",
+      "generic static analysis packet",
+      "non adapter repos",
+      "low confidence tasks"
+    ],
+    canCommentOn: [
+      "selected files",
+      "general risk warnings",
+      "smallest safe change policy",
+      "lack of strong specialist match"
+    ],
+    mustNotCommentOn: [
+      "n8n specific node behavior",
+      "specific external API semantics",
+      "domain specific contracts without evidence"
+    ],
+    handoffTriggers: ["control_flow", "data_transform", "integration_contracts"],
+    allowedOutputFields: [
+      "faultHypothesis",
+      "recommendedLocalChange",
+      "filesToEdit",
+      "filesToAvoid",
+      "mustNotChange",
+      "evidence",
+      "confidence",
+      "handoffTo"
+    ],
+    forbiddenOutputFields: ["contractObserved", "contractExpected"],
+    keywords: [],
+    nodeTypes: []
+  }
+};
+function getSpecialistRegistry() {
+  return Object.values(SPECIALIST_REGISTRY);
+}
+function getSpecialistProfile(id) {
+  const profile = SPECIALIST_REGISTRY[id];
+  if (!profile) {
+    throw new Error(`Unknown specialist ID: ${id}`);
+  }
+  return profile;
+}
+function isSpecialistId(value) {
+  return value in SPECIALIST_REGISTRY;
+}
+
+// ../brain/dist/network/router.js
+function routeTaskToPanel(input, candidateFiles, behaviorUnits) {
+  const taskText = (input.task || "").toLowerCase();
+  const intendedText = (input.intendedBehavior || "").toLowerCase();
+  const errorText = (input.errorTrace || "").toLowerCase();
+  const inputFiles = (input.files || []).map((f) => f.toLowerCase());
+  const taskWords = new Set(taskText.split(/[^a-z0-9_]+/));
+  const intendedWords = new Set(intendedText.split(/[^a-z0-9_]+/));
+  const errorWords = new Set(errorText.split(/[^a-z0-9_]+/));
+  const registry = getSpecialistRegistry();
+  const scores = [];
+  const commonNodeNames = /* @__PURE__ */ new Set(["code", "set", "if", "wait"]);
+  for (const profile of registry) {
+    if (profile.id === "generic_repo") {
+      continue;
+    }
+    let score = 0;
+    const reasons = [];
+    let fileMatch = false;
+    if (candidateFiles) {
+      for (const file of candidateFiles) {
+        const pathLower = file.path.toLowerCase();
+        const isExplicit = inputFiles.length === 0 || inputFiles.some((f) => pathLower.includes(f) || f.includes(pathLower));
+        if (isExplicit) {
+          if (file.adapterDomain === profile.id) {
+            score += 35;
+            reasons.push(`Explicit candidate file match on adapter domain: ${file.path}`);
+            fileMatch = true;
+          } else if (file.domainTags?.includes(profile.id)) {
+            score += 35;
+            reasons.push(`Explicit candidate file match on domain tag: ${file.path}`);
+            fileMatch = true;
+          }
+        }
       }
     }
-    for (const proof of receipt.proofPointers) {
-      const blobPath = resolveBlobPath(blobDir, proof.contentHash);
-      if (!existsSync4(blobPath)) {
-        errors.push(`UnresolvablePointer: blob not found for pointer ${proof.pointer} (hash: ${proof.contentHash})`);
-        continue;
+    let ownsWordMatch = false;
+    for (const item of profile.owns) {
+      const itemLower = item.toLowerCase();
+      if (taskWords.has(itemLower) || intendedWords.has(itemLower) || errorWords.has(itemLower)) {
+        if (commonNodeNames.has(itemLower)) {
+          const pattern = new RegExp(`\\b${itemLower}\\s+nodes?\\b|\\bn8n\\s+${itemLower}\\b`);
+          if (pattern.test(taskText) || pattern.test(intendedText) || pattern.test(errorText)) {
+            ownsWordMatch = true;
+            break;
+          }
+        } else {
+          ownsWordMatch = true;
+          break;
+        }
       }
-      const actualHash = await hashBlob(blobPath);
-      if (actualHash !== proof.contentHash) {
-        errors.push(`HashMismatch: proof ${proof.pointer} expected ${proof.contentHash}, got ${actualHash}`);
-        continue;
+    }
+    for (const nt of profile.nodeTypes) {
+      const ntLower = nt.toLowerCase();
+      const baseName = nt.split(".").pop().toLowerCase();
+      const hasBase = taskWords.has(baseName) || intendedWords.has(baseName) || errorWords.has(baseName);
+      const hasFull = taskWords.has(ntLower) || intendedWords.has(ntLower) || errorWords.has(ntLower);
+      if (hasFull) {
+        ownsWordMatch = true;
+        break;
       }
-      const reqDescriptor = requiredProof.find((r) => r.schemaName === proof.schemaName);
-      if (!reqDescriptor) {
-        warnings.push(`UnknownSchema: proof ${proof.pointer} has schema "${proof.schemaName}" not listed in requiredProof`);
+      if (hasBase) {
+        if (commonNodeNames.has(baseName)) {
+          const pattern = new RegExp(`\\b${baseName}\\s+nodes?\\b|\\bn8n\\s+${baseName}\\b`);
+          if (pattern.test(taskText) || pattern.test(intendedText) || pattern.test(errorText)) {
+            ownsWordMatch = true;
+            break;
+          }
+        } else {
+          ownsWordMatch = true;
+          break;
+        }
       }
-      if (proof.schemaName.startsWith("test_report")) {
-        try {
-          const blobContent = await readFile9(blobPath, "utf8");
-          const report = JSON.parse(blobContent);
-          if (report.status !== "pass" && report.passed !== true && report.success !== true) {
-            errors.push(`TestFailed: proof ${proof.pointer} (schema: ${proof.schemaName}) reports status "${report.status ?? "unknown"}"`);
+    }
+    if (ownsWordMatch) {
+      score += 35;
+      reasons.push("Explicit owned node or concept mentioned in task/error trace");
+      fileMatch = true;
+    }
+    for (const file of inputFiles) {
+      if (profile.keywords.some((k) => file.includes(k)) || profile.owns.some((o) => file.includes(o.toLowerCase()))) {
+        score += 35;
+        reasons.push(`Explicit file path match on keyword/ownership: ${file}`);
+        fileMatch = true;
+      }
+    }
+    let keywordMatched = false;
+    for (const keyword of profile.keywords) {
+      if (commonNodeNames.has(keyword)) {
+        const pattern = new RegExp(`\\b${keyword}\\s+nodes?\\b|\\bn8n\\s+${keyword}\\b`);
+        if (pattern.test(taskText) || pattern.test(intendedText)) {
+          keywordMatched = true;
+          break;
+        }
+      } else {
+        if (taskText.includes(keyword) || intendedText.includes(keyword)) {
+          keywordMatched = true;
+          break;
+        }
+      }
+    }
+    if (keywordMatched) {
+      score += 25;
+      reasons.push("Task/Intended behavior matched domain keywords");
+    }
+    let errorMatched = false;
+    if (errorText) {
+      for (const keyword of profile.keywords) {
+        if (commonNodeNames.has(keyword)) {
+          const pattern = new RegExp(`\\b${keyword}\\s+nodes?\\b|\\bn8n\\s+${keyword}\\b`);
+          if (pattern.test(errorText)) {
+            errorMatched = true;
+            break;
+          }
+        } else {
+          if (errorText.includes(keyword)) {
+            errorMatched = true;
+            break;
           }
-        } catch {
-          errors.push(`UnreadableProof: cannot parse proof blob for ${proof.pointer}`);
         }
       }
+      if (errorMatched) {
+        score += 20;
+        reasons.push("Error trace matched domain keywords");
+      }
     }
-    for (const changed of receipt.changedFiles) {
-      if (!isAllowedFile(changed.path)) {
-        errors.push(`ScopeViolation: patch touched out-of-scope file "${changed.path}"`);
+    let buMatchCount = 0;
+    if (behaviorUnits) {
+      for (const bu of behaviorUnits) {
+        if (bu.domain === profile.id || bu.specialist === profile.id) {
+          score += 15;
+          buMatchCount++;
+        }
+      }
+      if (buMatchCount > 0) {
+        reasons.push(`Matched ${buMatchCount} behavior units`);
       }
     }
-    for (const changed of receipt.changedFiles) {
-      if (!changed.prePatchHash.startsWith("sha256:") && changed.prePatchHash !== "sha256:new") {
-        errors.push(`InvalidHash: prePatchHash for ${changed.path} is not sha256 format`);
+    let adapterMatchCount = 0;
+    if (candidateFiles) {
+      for (const file of candidateFiles) {
+        if (file.adapterDomain === profile.id || file.domainTags?.includes(profile.id)) {
+          score += 15;
+          adapterMatchCount++;
+        }
       }
-      if (!changed.postPatchHash.startsWith("sha256:")) {
-        errors.push(`InvalidHash: postPatchHash for ${changed.path} is not sha256 format`);
+      if (adapterMatchCount > 0) {
+        reasons.push(`Candidate file metadata matches domain: ${adapterMatchCount} files`);
       }
-      const matchingPatch = receipt.proofPointers.find((p) => p.schemaName === "patch_hash" && p.contentHash === changed.postPatchHash);
-      if (!matchingPatch) {
-        warnings.push(`NoMatchingPatchProof: no patch_hash proof matches postPatchHash for ${changed.path}`);
+    }
+    let sideEffectMatch = false;
+    if (candidateFiles) {
+      for (const file of candidateFiles) {
+        if (file.adapterSideEffects) {
+          for (const se of file.adapterSideEffects) {
+            const seLower = se.toLowerCase();
+            if (profile.owns.some((o) => seLower.includes(o.toLowerCase()))) {
+              score += 10;
+              sideEffectMatch = true;
+            }
+          }
+        }
       }
     }
+    if (profile.id === "integration_contracts" && (taskText.includes("auth") || taskText.includes("credential") || taskText.includes("api"))) {
+      score += 10;
+      sideEffectMatch = true;
+    }
+    if (sideEffectMatch) {
+      reasons.push("Matched side effect or API capabilities");
+    }
+    if (score > 0) {
+      scores.push({ specialist: profile.id, score, reasons });
+    }
+  }
+  scores.sort((a, b) => b.score - a.score);
+  const topScore = scores.length > 0 ? scores[0].score : 0;
+  if (topScore < 30) {
     return {
-      valid: errors.length === 0,
-      errors,
-      warnings
+      primarySpecialist: "generic_repo",
+      panel: ["generic_repo"],
+      confidence: "low",
+      reason: "No specialist domain met the primary relevance threshold of 30.",
+      scores: [
+        { specialist: "generic_repo", score: 1, reasons: ["Fallback generic_repo baseline"] },
+        ...scores
+      ]
     };
   }
-};
-function resolveBlobPath(blobDir, contentHash) {
-  const hex = contentHash.replace("sha256:", "");
-  return `${blobDir}/sha256_${hex}`;
+  const primarySpecialist = scores[0].specialist;
+  const panel = [primarySpecialist];
+  for (let i = 1; i < scores.length; i++) {
+    const item = scores[i];
+    if (item.score >= 15 && topScore - item.score <= 35) {
+      panel.push(item.specialist);
+    }
+  }
+  const confidence = topScore >= 60 ? "high" : topScore >= 45 ? "medium" : "low";
+  const panelString = panel.join(", ");
+  return {
+    primarySpecialist,
+    panel,
+    confidence,
+    reason: `Routed to ${panelString} based on primary score of ${topScore} (${scores[0].reasons.join("; ")}).`,
+    scores: [
+      ...scores,
+      { specialist: "generic_repo", score: 1, reasons: ["Generic fallback available"] }
+    ]
+  };
+}
+
+// ../brain/dist/network/scope.js
+function slicePacketForSpecialist(packet, profile) {
+  const allowedDomains = /* @__PURE__ */ new Set([profile.id]);
+  profile.handoffTriggers.forEach((d) => allowedDomains.add(d));
+  packet.route.panel.forEach((d) => allowedDomains.add(d));
+  const selectedFiles = packet.selectedFiles.filter((file) => {
+    const fileDomain = file.adapterDomain;
+    if (!fileDomain || fileDomain === "generic_repo") {
+      return true;
+    }
+    if (fileDomain === profile.id) {
+      return true;
+    }
+    if (packet.route.panel.includes(fileDomain)) {
+      return true;
+    }
+    const pathLower = file.path.toLowerCase();
+    if (profile.keywords.some((k) => pathLower.includes(k))) {
+      return true;
+    }
+    return false;
+  });
+  const allowedFilesPaths = selectedFiles.map((f) => f.path);
+  const forbiddenFilesPaths = packet.selectedFiles.map((f) => f.path).filter((p) => !allowedFilesPaths.includes(p));
+  const behaviorUnits = packet.behaviorUnits.filter((bu) => {
+    return bu.specialist === profile.id || bu.domain === profile.id || allowedDomains.has(bu.domain);
+  });
+  const pathExamples = packet.pathExamples.filter((pe) => {
+    return pe.domains.some((d) => allowedDomains.has(d));
+  });
+  const riskWarnings = packet.riskWarnings.filter((rw) => {
+    if (rw.specialist === profile.id || rw.specialist && allowedDomains.has(rw.specialist)) {
+      return true;
+    }
+    if (rw.file && allowedFilesPaths.includes(rw.file)) {
+      return true;
+    }
+    return false;
+  });
+  const evidence = packet.evidence.filter((ev) => {
+    if (ev.file && allowedFilesPaths.includes(ev.file)) {
+      return true;
+    }
+    return ev.confidence === "high" || ev.kind === "keyword";
+  });
+  const scopePolicy = {
+    specialist: profile.id,
+    allowedFiles: allowedFilesPaths,
+    forbiddenFiles: forbiddenFilesPaths,
+    allowedDomains: Array.from(allowedDomains),
+    forbiddenClaims: profile.mustNotCommentOn,
+    mustNotModify: forbiddenFilesPaths,
+    handoffRequiredWhen: profile.handoffTriggers.map((id) => `requires handoff when modifying ${id} surface`)
+  };
+  return {
+    packetVersion: "scoped_specialist_v0",
+    task: packet.task,
+    specialist: profile.id,
+    profile,
+    route: packet.route,
+    selectedFiles,
+    behaviorUnits,
+    pathExamples,
+    riskWarnings,
+    scopePolicy,
+    smallestSafeChangePolicy: packet.smallestSafeChangePolicy,
+    evidence
+  };
 }
-async function hashBlob(blobPath) {
-  const buf = await readFile9(blobPath);
-  return `sha256:${createHash("sha256").update(buf).digest("hex")}`;
+function validateAdvisory(advisory, scopedPacket, profile) {
+  const errors = [];
+  const warnings = [];
+  if (advisory.scopeStatus === "out_of_scope") {
+    if (advisory.recommendedLocalChange) {
+      errors.push("Advisory scopeStatus is out_of_scope, but recommendedLocalChange is present.");
+    }
+    if (advisory.filesToEdit && advisory.filesToEdit.length > 0) {
+      errors.push("Advisory scopeStatus is out_of_scope, but filesToEdit is not empty.");
+    }
+    if (advisory.specialist !== "generic_repo") {
+      if (!advisory.handoffTo || advisory.handoffTo.length === 0) {
+        errors.push("Advisory scopeStatus is out_of_scope, but handoffTo is empty or missing.");
+      }
+    }
+  }
+  if (advisory.recommendedLocalChange && advisory.scopeStatus === "out_of_scope") {
+    errors.push("Advisory provides a recommendedLocalChange but scopeStatus is out_of_scope.");
+  }
+  if (advisory.filesToEdit) {
+    for (const file of advisory.filesToEdit) {
+      if (!scopedPacket.scopePolicy.allowedFiles.includes(file)) {
+        errors.push(`Advisory recommends editing file outside allowed scope: ${file}`);
+      }
+      if (scopedPacket.scopePolicy.forbiddenFiles.includes(file)) {
+        errors.push(`Advisory recommends editing forbidden file: ${file}`);
+      }
+      if (scopedPacket.scopePolicy.mustNotModify.includes(file)) {
+        errors.push(`Advisory recommends editing file listed in mustNotModify: ${file}`);
+      }
+    }
+  }
+  const textToScan = [
+    advisory.faultHypothesis || "",
+    advisory.recommendedLocalChange || "",
+    advisory.contractObserved || "",
+    advisory.contractExpected || ""
+  ].join(" ").toLowerCase();
+  for (const claim of scopedPacket.scopePolicy.forbiddenClaims) {
+    if (textToScan.includes(claim.toLowerCase())) {
+      errors.push(`Advisory violates scope by discussing forbidden claim/concept: "${claim}"`);
+    }
+  }
+  if (advisory.confidence === "high" && (!advisory.evidence || advisory.evidence.length === 0)) {
+    errors.push("Advisory has high confidence but provides no evidence.");
+  }
+  if (advisory.specialist === "generic_repo") {
+    const n8nKeywords = ["slack", "gmail", "if node", "httprequest", "set node", "merge node", "splitinbatches"];
+    for (const kw of n8nKeywords) {
+      if (textToScan.includes(kw)) {
+        warnings.push(`Generic repository specialist discusses n8n-specific node behavior: "${kw}"`);
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+
+// ../brain/dist/network/packet.js
+function buildExpertNetworkPacket(input) {
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  const task = input.task || "";
+  const projectRoot = input.projectRoot || "";
+  const adapterId = input.adapterId || null;
+  const maxFiles = input.maxFiles || 8;
+  let selectedFiles = [];
+  let behaviorUnits = [];
+  const rawArtifact = input.scanArtifact;
+  if (rawArtifact && rawArtifact.files) {
+    const filesRecord = rawArtifact.files;
+    const allFiles = [];
+    for (const [relPath, file] of Object.entries(filesRecord)) {
+      const gravity = file.gravity !== void 0 ? file.gravity : 0;
+      const staticGravity = file.staticGravity !== void 0 ? file.staticGravity : 0;
+      const heat = file.heat !== void 0 ? file.heat : 0;
+      const severity = file.canonicalSeverity !== void 0 ? file.canonicalSeverity : void 0;
+      allFiles.push({
+        path: relPath,
+        reason: "File analysis from project scan.",
+        gravity,
+        staticGravity,
+        heat,
+        severity,
+        domainTags: file.domainTags,
+        adapterDomain: file.adapterDomain,
+        executionRole: file.executionRole,
+        adapterSideEffects: file.adapterSideEffects,
+        blastRadius: gravity > 70 ? "high" : gravity > 40 ? "medium" : "low",
+        includeMode: "excerpt"
+      });
+    }
+    allFiles.sort((a, b) => (b.gravity || 0) - (a.gravity || 0));
+    if (input.files && input.files.length > 0) {
+      const inputLower = input.files.map((f) => f.toLowerCase());
+      selectedFiles = allFiles.filter((f) => {
+        const pathLower = f.path.toLowerCase();
+        return inputLower.some((inf) => pathLower.includes(inf) || inf.includes(pathLower));
+      });
+    } else {
+      selectedFiles = allFiles.slice(0, maxFiles);
+    }
+    selectedFiles.forEach((file, index) => {
+      if (file.adapterDomain) {
+        behaviorUnits.push({
+          id: `bu_${file.path}_node`,
+          unitType: "node",
+          unitName: file.path.split("/").pop() || file.path,
+          file: file.path,
+          domain: file.adapterDomain,
+          specialist: file.adapterDomain,
+          gravityRank: index + 1,
+          gravity: file.gravity,
+          source: "scan",
+          validatedBy: ["static_analysis"],
+          confidence: "medium",
+          evidence: [
+            {
+              kind: "scan",
+              file: file.path,
+              summary: `File identified with gravity ${file.gravity} in domain ${file.adapterDomain}.`,
+              confidence: "medium"
+            }
+          ]
+        });
+      }
+    });
+  } else if (input.files && input.files.length > 0) {
+    selectedFiles = input.files.map((file) => ({
+      path: file,
+      reason: "User explicitly specified file.",
+      blastRadius: "medium",
+      includeMode: "excerpt"
+    }));
+  }
+  const route = routeTaskToPanel({
+    task: input.task,
+    files: input.files,
+    errorTrace: input.errorTrace,
+    intendedBehavior: input.intendedBehavior
+  }, selectedFiles, behaviorUnits);
+  const riskWarnings = [];
+  const taskTextLower = task.toLowerCase();
+  selectedFiles.forEach((file) => {
+    if (file.gravity && file.gravity > 70) {
+      riskWarnings.push({
+        id: `rw_${file.path}_high_gravity`,
+        level: "critical",
+        file: file.path,
+        specialist: file.adapterDomain,
+        message: "High-gravity file is central to the project. Modifying it may have a large blast radius.",
+        reason: `Gravity score is ${file.gravity}.`,
+        relatedSideEffects: file.adapterSideEffects || []
+      });
+    }
+    if (file.severity && file.severity >= 4) {
+      riskWarnings.push({
+        id: `rw_${file.path}_high_severity`,
+        level: "warning",
+        file: file.path,
+        specialist: file.adapterDomain,
+        message: "High-severity smells detected in this file.",
+        reason: `Smell severity score is ${file.severity}.`,
+        relatedSideEffects: []
+      });
+    }
+    if (file.adapterSideEffects && file.adapterSideEffects.length > 0) {
+      const hasSecurity = file.adapterSideEffects.some((se) => {
+        const sel = se.toLowerCase();
+        return sel.includes("auth") || sel.includes("credential") || sel.includes("webhook");
+      });
+      if (hasSecurity) {
+        riskWarnings.push({
+          id: `rw_${file.path}_security_side_effects`,
+          level: "critical",
+          file: file.path,
+          specialist: file.adapterDomain,
+          message: "Security-sensitive side effects detected. Do not modify credentials or auth configuration.",
+          reason: `File side effects: ${file.adapterSideEffects.join(", ")}`,
+          relatedSideEffects: file.adapterSideEffects
+        });
+      }
+    }
+  });
+  if (taskTextLower.includes("auth") || taskTextLower.includes("credential") || taskTextLower.includes("password")) {
+    riskWarnings.push({
+      id: "rw_task_security_sensitive",
+      level: "critical",
+      message: "Do not modify credentials or auth configuration unless explicitly required.",
+      reason: "Security or credential keyword match in task description.",
+      relatedSideEffects: []
+    });
+  }
+  const smallestSafeChangePolicy = {
+    summary: "Make the smallest localized change that addresses the requested fault. Do not modify unrelated files, triggers, credentials, auth configuration, or neighboring workflow nodes unless this packet explicitly lists them as required.",
+    rules: [
+      "Locate the exact failure site before making edits.",
+      "Do not perform general cleanup or refactoring.",
+      "Verify modifications against existing contracts and Jest fixtures."
+    ],
+    filesToAvoid: selectedFiles.filter((f) => f.blastRadius === "high").map((f) => f.path),
+    forbiddenEditClasses: ["credentials", "auth_configuration", "global_refactoring"]
+  };
+  const registry = getSpecialistRegistry();
+  const scopePolicy = [];
+  const scopedPackets = [];
+  const stubAdvisories = [];
+  const evidence = [
+    {
+      kind: "user_file",
+      summary: `User provided task: "${task}"`,
+      confidence: "high"
+    }
+  ];
+  if (route.primarySpecialist !== "generic_repo") {
+    evidence.push({
+      kind: "keyword",
+      summary: `Deterministic router mapped task to specialist panel with confidence ${route.confidence}.`,
+      confidence: "high"
+    });
+  } else {
+    evidence.push({
+      kind: "fallback",
+      summary: "Deterministic router fell back to generic_repo due to low domain score.",
+      confidence: "low"
+    });
+  }
+  const packetPlaceholder = {
+    packetVersion: "expert_network_v0",
+    createdAt,
+    projectRoot,
+    task,
+    adapterId,
+    route,
+    selectedFiles,
+    behaviorUnits,
+    pathExamples: [],
+    riskWarnings,
+    scopePolicy: [],
+    corpusQuality: [],
+    smallestSafeChangePolicy,
+    scopedPackets: [],
+    stubAdvisories: [],
+    evidence
+  };
+  for (const profile of registry) {
+    const scopedPacket = slicePacketForSpecialist(packetPlaceholder, profile);
+    scopePolicy.push(scopedPacket.scopePolicy);
+    scopedPackets.push(scopedPacket);
+    const inPanel = route.panel.includes(profile.id);
+    let advisory;
+    if (inPanel) {
+      advisory = {
+        specialist: profile.id,
+        scopeStatus: "in_scope",
+        faultHypothesis: `The issue likely resides in the ${profile.label} domain, specifically affecting the task: "${task}".`,
+        contractObserved: "Dynamic contract observation not computed in Phase 1.",
+        contractExpected: "Refer to node schemas or Jest test fixtures for contract expectations.",
+        recommendedLocalChange: `Perform a localized fix targeting the ${profile.label} components. Make the smallest safe change and avoid modifying unrelated nodes.`,
+        filesToEdit: scopedPacket.selectedFiles.map((f) => f.path),
+        filesToAvoid: smallestSafeChangePolicy.filesToAvoid,
+        mustNotChange: scopedPacket.scopePolicy.forbiddenFiles,
+        handoffTo: [],
+        evidence: [
+          {
+            kind: "keyword",
+            summary: `Routed to ${profile.label} due to deterministic keyword match in task text.`,
+            confidence: "medium"
+          }
+        ],
+        confidence: route.confidence
+      };
+    } else {
+      advisory = {
+        specialist: profile.id,
+        scopeStatus: "out_of_scope",
+        filesToEdit: [],
+        filesToAvoid: [],
+        mustNotChange: [],
+        handoffTo: profile.id === "generic_repo" ? [] : [route.primarySpecialist],
+        evidence: [],
+        confidence: "low"
+      };
+    }
+    const validation = validateAdvisory(advisory, scopedPacket, profile);
+    if (!validation.valid) {
+      console.error(`[vibe-splain] Generated stub advisory failed validation for ${profile.id}:`, validation.errors.join("; "));
+    }
+    stubAdvisories.push(advisory);
+  }
+  const corpusQuality = registry.map((p) => {
+    return {
+      domain: p.id,
+      score: p.id === "generic_repo" ? 0 : 50,
+      state: p.id === "generic_repo" ? "not_computed" : "pilot_trainable",
+      behaviorUnitCount: 0,
+      highConfidenceCount: 0,
+      topGravityCoverage: 0,
+      typeSchemaCoverage: 0,
+      validationStrength: 0,
+      notes: ["Phase 1 placeholder quality score. Builder not executed."]
+    };
+  });
+  return {
+    packetVersion: "expert_network_v0",
+    createdAt,
+    projectRoot,
+    task,
+    adapterId,
+    route,
+    selectedFiles,
+    behaviorUnits,
+    pathExamples: [],
+    riskWarnings,
+    scopePolicy,
+    corpusQuality,
+    smallestSafeChangePolicy,
+    scopedPackets,
+    stubAdvisories,
+    evidence
+  };
+}
+
+// ../brain/dist/network/gateIndex.js
+function isDenoisedImporter(relPath) {
+  if (!relPath)
+    return false;
+  const norm = relPath.replace(/\\/g, "/");
+  const segs = norm.split("/");
+  const excludedDirs = /* @__PURE__ */ new Set([
+    "node_modules",
+    "vendor",
+    "vendored",
+    "site-packages",
+    "third_party",
+    "third-party",
+    ".yarn",
+    "bower_components",
+    "venv",
+    ".venv",
+    "env",
+    "virtualenv",
+    ".git",
+    ".vibe-splainer",
+    "dist",
+    "build",
+    "out",
+    "target",
+    ".next",
+    ".nuxt",
+    ".docusaurus",
+    "coverage",
+    ".nyc_output",
+    ".cache"
+  ]);
+  for (const s of segs) {
+    const sLower = s.toLowerCase();
+    if (excludedDirs.has(sLower)) {
+      return false;
+    }
+    if (sLower.endsWith(".venv")) {
+      return false;
+    }
+  }
+  const fileName = segs[segs.length - 1];
+  const fileNameLower = fileName.toLowerCase();
+  if (/\.min\.[a-z]+$/.test(fileNameLower) || fileNameLower.includes(".min.")) {
+    return false;
+  }
+  if (/\.generated\./.test(fileNameLower) || fileNameLower.includes("__generated__")) {
+    return false;
+  }
+  if (fileNameLower.endsWith(".lock")) {
+    return false;
+  }
+  if (norm.startsWith("virtual:") || norm.startsWith("__virtual:") || norm.startsWith("webpack:")) {
+    return false;
+  }
+  return true;
+}
+function hasBehavioralSubstance(file) {
+  const isTypeDefinition = file.frameworkRole === "type_definition";
+  const cyclomatic = file.gravitySignals?.cyclomatic ?? 0;
+  const hasSideEffects = (file.sideEffectProfile ?? []).some((e) => e !== "none_detected");
+  const hasStrongRiskType = (file.riskTypes ?? []).some((r) => r === "state_machine" || r === "mutation_orchestration" || r === "registry_bottleneck" || r === "side_effect_coupling");
+  return !isTypeDefinition && (cyclomatic >= 5 || hasSideEffects || hasStrongRiskType);
+}
+function buildGateIndex(store) {
+  const files = {};
+  if (store && store.files) {
+    for (const [key, file] of Object.entries(store.files)) {
+      const dependents = (file.importedBy ?? []).filter(isDenoisedImporter);
+      const sideEffects = (file.sideEffectProfile ?? []).filter((e) => e !== "none_detected");
+      files[key] = {
+        relativePath: file.relativePath,
+        gravity: file.gravity ?? 0,
+        demoteReason: file.demoteReason,
+        hasBehavioralSubstance: hasBehavioralSubstance(file),
+        dependents,
+        fanIn: file.gravitySignals?.fanIn ?? dependents.length,
+        fanOut: file.gravitySignals?.fanOut ?? 0,
+        centrality: file.gravitySignals?.centrality ?? 0,
+        severity: file.canonicalSeverity ?? 1,
+        sideEffects,
+        riskTypes: file.riskTypes ?? []
+      };
+    }
+  }
+  return { files };
+}
+
+// ../brain/dist/network/escalation.js
+var SECURITY_PATH = /\b(auth|credential|secret|token|webhook|payment|password|oauth|session)\b/i;
+var SENSITIVE_EFFECTS = /* @__PURE__ */ new Set([
+  "database_write",
+  "server_action",
+  "trpc_mutation",
+  "email_send",
+  "external_api_call"
+]);
+var NOTABLE_RISKS = /* @__PURE__ */ new Set([
+  "state_machine",
+  "mutation_orchestration",
+  "side_effect_coupling",
+  "async_race_risk",
+  "registry_bottleneck",
+  "error_swallowing"
+]);
+function buildEscalationContext(targetFile, gateIndex) {
+  const file = lookupFile(targetFile, gateIndex);
+  if (!file)
+    return null;
+  const rel = file.relativePath;
+  const gravity = file.gravity;
+  const dependents = file.dependents;
+  const dependentsCount = dependents.length;
+  const sideEffects = file.sideEffects;
+  const riskTypes = file.riskTypes;
+  const severity = file.severity;
+  const gravity_tier = gravity > 70 ? "high" : gravity > 40 ? "medium" : "low";
+  const raw_substance_tier = file.hasBehavioralSubstance && dependentsCount >= 10 ? "high" : file.hasBehavioralSubstance && dependentsCount >= 4 ? "medium" : "low";
+  const tierOrder = { low: 1, medium: 2, high: 3 };
+  let blastRadius = tierOrder[gravity_tier] >= tierOrder[raw_substance_tier] ? gravity_tier : raw_substance_tier;
+  const isGeneratedOrVendored = !isDenoisedImporter(targetFile) || file.demoteReason !== null && file.demoteReason !== "no inbound references from application code";
+  if (isGeneratedOrVendored) {
+    blastRadius = "low";
+  }
+  const riskWarnings = buildRiskWarnings(rel, gravity, dependentsCount, severity, sideEffects, riskTypes);
+  return {
+    targetFile: rel,
+    gravity,
+    blastRadius,
+    dependents,
+    dependentCount: dependentsCount,
+    fanIn: file.fanIn,
+    fanOut: file.fanOut,
+    centrality: file.centrality,
+    severity,
+    sideEffects,
+    riskTypes,
+    riskWarnings,
+    smallestSafeChange: buildSafeChangePolicy(blastRadius)
+  };
+}
+function lookupFile(targetFile, gateIndex) {
+  const files = gateIndex?.files;
+  if (!files)
+    return null;
+  const norm = targetFile.replace(/\\/g, "/");
+  if (files[norm])
+    return files[norm];
+  const suffixHits = [];
+  for (const [key, rec] of Object.entries(files)) {
+    if (norm === key || norm.endsWith("/" + key) || key.endsWith("/" + norm)) {
+      suffixHits.push(rec);
+    }
+  }
+  return suffixHits.length === 1 ? suffixHits[0] : null;
+}
+function buildRiskWarnings(rel, gravity, dependentCount, severity, sideEffects, riskTypes) {
+  const warnings = [];
+  if (gravity > 70) {
+    warnings.push({
+      id: `rw_${rel}_blast_radius`,
+      level: "critical",
+      message: `Central file \u2014 editing it has a large blast radius. ${dependentCount} file(s) depend on it.`,
+      reason: `Gravity ${gravity}/100; fan-in ${dependentCount}.`
+    });
+  }
+  if (severity >= 4) {
+    warnings.push({
+      id: `rw_${rel}_severity`,
+      level: "warning",
+      message: "High-severity smells already present here. Avoid making them worse.",
+      reason: `Canonical severity ${severity}/5.`
+    });
+  }
+  if (SECURITY_PATH.test(rel)) {
+    warnings.push({
+      id: `rw_${rel}_security_path`,
+      level: "critical",
+      message: "Security-sensitive file (auth/credential/webhook/payment). Do not alter auth or credential handling unless that is the explicit task.",
+      reason: `Path matches security-sensitive pattern.`
+    });
+  }
+  const sensitive = sideEffects.filter((e) => SENSITIVE_EFFECTS.has(e));
+  if (sensitive.length > 0) {
+    warnings.push({
+      id: `rw_${rel}_side_effects`,
+      level: "warning",
+      message: `This file performs side effects (${sensitive.join(", ")}). Preserve existing behavior; do not drop or reorder them.`,
+      reason: `Side-effect profile: ${sensitive.join(", ")}.`
+    });
+  }
+  const notable = riskTypes.filter((r) => NOTABLE_RISKS.has(r));
+  if (notable.length > 0) {
+    warnings.push({
+      id: `rw_${rel}_risk_types`,
+      level: "info",
+      message: `Structural risk patterns detected (${notable.join(", ")}). Trace the affected paths before editing.`,
+      reason: `Risk types: ${notable.join(", ")}.`
+    });
+  }
+  return warnings;
+}
+function buildSafeChangePolicy(blastRadius) {
+  const rules = [
+    "Locate the exact failure site before editing.",
+    "Make the smallest localized change that addresses the task.",
+    "Do not perform general cleanup or refactoring.",
+    "Do not modify unrelated files, credentials, or auth configuration."
+  ];
+  if (blastRadius === "high") {
+    rules.push("This file is load-bearing: verify each dependent still type-checks against the changed surface.");
+  }
+  return {
+    summary: "Make the smallest localized change that addresses the requested task. Do not modify unrelated files, credentials, auth configuration, or neighboring modules unless the task explicitly requires it.",
+    rules,
+    forbiddenEditClasses: ["credentials", "auth_configuration", "global_refactoring"]
+  };
 }
 
 // dist/export/ArtifactBundleWriter.js
 import { join as join10 } from "path";
-import { writeFile as writeFile7, mkdir as mkdir6, rm, rename } from "fs/promises";
-import { createHash as createHash2 } from "crypto";
+import { writeFile as writeFile6, mkdir as mkdir6, rm, rename } from "fs/promises";
+import { createHash } from "crypto";
 var ArtifactBundleWriter = class {
   projectRoot;
   constructor(projectRoot) {
@@ -3361,9 +4740,9 @@ var ArtifactBundleWriter = class {
     try {
       await rm(stagingDir, { recursive: true, force: true });
       await rm(oldDir, { recursive: true, force: true });
-      const { existsSync: existsSync9 } = await import("fs");
+      const { existsSync: existsSync8 } = await import("fs");
       const { cp } = await import("fs/promises");
-      if (existsSync9(outputDir)) {
+      if (existsSync8(outputDir)) {
         await cp(outputDir, stagingDir, { recursive: true });
       } else {
         await mkdir6(stagingDir, { recursive: true });
@@ -3372,13 +4751,13 @@ var ArtifactBundleWriter = class {
       for (const artifact of artifacts) {
         const destPath = join10(stagingDir, artifact.path);
         await mkdir6(join10(destPath, ".."), { recursive: true });
-        await writeFile7(destPath, artifact.content);
+        await writeFile6(destPath, artifact.content);
         const contentStr = artifact.content;
         const buffer = typeof contentStr === "string" ? Buffer.from(contentStr, "utf-8") : contentStr;
         manifestArtifacts.push({
           type: artifact.type,
           path: artifact.path,
-          checksum: "sha256:" + createHash2("sha256").update(buffer).digest("hex"),
+          checksum: "sha256:" + createHash("sha256").update(buffer).digest("hex"),
           sizeBytes: buffer.length
         });
       }
@@ -3388,9 +4767,9 @@ var ArtifactBundleWriter = class {
         projectRoot: this.projectRoot,
         artifacts: manifestArtifacts
       };
-      await writeFile7(join10(stagingDir, "artifact_manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+      await writeFile6(join10(stagingDir, "artifact_manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
       let swapped = false;
-      if (existsSync9(outputDir)) {
+      if (existsSync8(outputDir)) {
         await rename(outputDir, oldDir);
         swapped = true;
       }
@@ -3426,10 +4805,10 @@ var JsonRenderer = class {
 };
 
 // dist/export/renderers/HtmlRenderer.js
-import { join as join11, dirname as dirname3, relative as relative3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { existsSync as existsSync5, readFileSync, readdirSync, statSync } from "fs";
-var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+import { join as join11, dirname as dirname4, relative as relative3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { existsSync as existsSync5, readFileSync as readFileSync2, readdirSync, statSync } from "fs";
+var __dirname2 = dirname4(fileURLToPath3(import.meta.url));
 function getAllFiles(dirPath, arrayOfFiles = []) {
   const files = readdirSync(dirPath);
   files.forEach(function(file) {
@@ -3482,7 +4861,7 @@ var HtmlRenderer = class {
     for (const file of allFiles) {
       const relPath = relative3(templateDir, file);
       if (relPath === "index.html") {
-        const templateHtml = readFileSync(file, "utf8");
+        const templateHtml = readFileSync2(file, "utf8");
         const injection = `<script>window.__VIBE_DOSSIER__ = ${JSON.stringify(viewModel)};</script>`;
         const bakedHtml = templateHtml.replace("<!-- VIBE_DOSSIER_INJECTION_POINT -->", injection);
         artifacts.push({
@@ -3494,41 +4873,19 @@ var HtmlRenderer = class {
         artifacts.push({
           type: "asset",
           path: join11("ui", relPath),
-          content: readFileSync(file)
+          content: readFileSync2(file)
         });
       }
-    }
-    return artifacts;
-  }
-};
-
-// dist/export/renderers/DeltaRenderer.js
-var DeltaRenderer = class {
-  render(_viewModel, store) {
-    const deltaTargets = Object.values(store.files).filter((pf) => pf.isRealSource).sort((a, b) => b.gravity - a.gravity).map((pf) => ({
-      path: pf.relativePath,
-      gravity: Math.round(pf.gravity),
-      isLoadBearing: pf.canonicalLoadBearing,
-      blastRadius: pf.importedBy,
-      pillarHint: pf.pillarHint
-    }));
-    return [
-      {
-        type: "delta",
-        path: "delta_targets.json",
-        content: JSON.stringify(deltaTargets, null, 2)
-      }
-    ];
+    }
+    return artifacts;
   }
 };
 
 // dist/export/renderers/AgentMarkdownRenderer.js
 var AgentMarkdownRenderer = class {
   budget;
-  bindings;
-  constructor(budget = 8e3, bindings = null) {
+  constructor(budget = 8e3) {
     this.budget = budget;
-    this.bindings = bindings;
   }
   render(viewModel, store) {
     let md = `# Architectural Dossier: ${viewModel.projectRoot}
@@ -3591,23 +4948,6 @@ ${viewModel.map.brief}
         md += `**Narrative**: ${card.narrative}
 `;
       }
-      if (this.bindings && this.bindings.files[path2]) {
-        const fileBinding = this.bindings.files[path2];
-        const criticalFunctions = fileBinding.functions.filter((fn) => fn.semanticActions.length > 0 || fn.isEntrypoint);
-        if (criticalFunctions.length > 0) {
-          md += `
-**Critical Functions**:
-`;
-          for (const fn of criticalFunctions) {
-            md += `- \`${fn.displayName}\` (lines ${fn.startLine}-${fn.endLine})${fn.isEntrypoint ? " [Entrypoint]" : ""}
-`;
-            for (const action of fn.semanticActions) {
-              md += `  - **${action.actionKind}**${action.targetModel ? ` on ${action.targetModel}` : ""}: \`${action.calleeText}\` (line ${action.sourceLine})
-`;
-            }
-          }
-        }
-      }
       if (recs.length > 0) {
         md += `
 **Safe Patch Strategies**:
@@ -3704,8 +5044,8 @@ var GraphRenderer = class {
 };
 
 // dist/store/BlobStore.js
-import { createHash as createHash3 } from "crypto";
-import { mkdir as mkdir7, writeFile as writeFile8, open, rename as rename2, stat } from "fs/promises";
+import { createHash as createHash2 } from "crypto";
+import { mkdir as mkdir7, writeFile as writeFile7, open, rename as rename2, stat } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
 import { join as join12 } from "path";
 var BlobStore = class {
@@ -3722,14 +5062,14 @@ var BlobStore = class {
   async writeAtomic(payload) {
     await this.ensureDirs();
     const buf = typeof payload === "string" ? Buffer.from(payload, "utf8") : payload;
-    const hex = createHash3("sha256").update(buf).digest("hex");
+    const hex = createHash2("sha256").update(buf).digest("hex");
     const contentHash = `sha256:${hex}`;
     const blobPath = join12(this.blobsDir, `sha256_${hex}`);
     if (existsSync6(blobPath)) {
       return { contentHash, blobPath };
     }
     const tmpPath = join12(this.tmpDir, `tmp_${hex}_${Date.now()}`);
-    await writeFile8(tmpPath, buf);
+    await writeFile7(tmpPath, buf);
     const fh = await open(tmpPath, "r");
     try {
       await fh.datasync();
@@ -3740,8 +5080,8 @@ var BlobStore = class {
     return { contentHash, blobPath };
   }
   async readBlob(blobPath) {
-    const { readFile: readFile16 } = await import("fs/promises");
-    return readFile16(blobPath);
+    const { readFile: readFile14 } = await import("fs/promises");
+    return readFile14(blobPath);
   }
   async blobExists(contentHash) {
     const hex = contentHash.replace("sha256:", "");
@@ -3754,9 +5094,9 @@ var BlobStore = class {
   }
   async verifyIntegrity(blobPath, expectedHash) {
     try {
-      const { readFile: readFile16 } = await import("fs/promises");
-      const buf = await readFile16(blobPath);
-      const hex = createHash3("sha256").update(buf).digest("hex");
+      const { readFile: readFile14 } = await import("fs/promises");
+      const buf = await readFile14(blobPath);
+      const hex = createHash2("sha256").update(buf).digest("hex");
       return `sha256:${hex}` === expectedHash;
     } catch {
       return false;
@@ -3765,8 +5105,8 @@ var BlobStore = class {
   /** List all blob paths for GC reference counting */
   async listBlobPaths() {
     try {
-      const { readdir: readdir3 } = await import("fs/promises");
-      const files = await readdir3(this.blobsDir);
+      const { readdir: readdir2 } = await import("fs/promises");
+      const files = await readdir2(this.blobsDir);
       return files.filter((f) => f.startsWith("sha256_")).map((f) => join12(this.blobsDir, f));
     } catch {
       return [];
@@ -3782,9 +5122,9 @@ var BlobStore = class {
   }
 };
 async function hashFile(filePath) {
-  const { readFile: readFile16 } = await import("fs/promises");
-  const buf = await readFile16(filePath);
-  return `sha256:${createHash3("sha256").update(buf).digest("hex")}`;
+  const { readFile: readFile14 } = await import("fs/promises");
+  const buf = await readFile14(filePath);
+  return `sha256:${createHash2("sha256").update(buf).digest("hex")}`;
 }
 
 // dist/store/PointerStore.js
@@ -3798,11 +5138,11 @@ var E_ALREADY_LOCKED = new Error("mutex already locked");
 var E_CANCELED = new Error("request for lock canceled");
 var __awaiter$2 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve) {
-      resolve(value);
+    return value instanceof P ? value : new P(function(resolve2) {
+      resolve2(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve, reject) {
+  return new (P || (P = Promise))(function(resolve2, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -3818,7 +5158,7 @@ var __awaiter$2 = function(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -3833,8 +5173,8 @@ var Semaphore = class {
   acquire(weight = 1, priority = 0) {
     if (weight <= 0)
       throw new Error(`invalid weight ${weight}: must be positive`);
-    return new Promise((resolve, reject) => {
-      const task = { resolve, reject, weight, priority };
+    return new Promise((resolve2, reject) => {
+      const task = { resolve: resolve2, reject, weight, priority };
       const i = findIndexFromEnd(this._queue, (other) => priority <= other.priority);
       if (i === -1 && weight <= this._value) {
         this._dispatchItem(task);
@@ -3859,10 +5199,10 @@ var Semaphore = class {
     if (this._couldLockImmediately(weight, priority)) {
       return Promise.resolve();
     } else {
-      return new Promise((resolve) => {
+      return new Promise((resolve2) => {
         if (!this._weightedWaiters[weight - 1])
           this._weightedWaiters[weight - 1] = [];
-        insertSorted(this._weightedWaiters[weight - 1], { resolve, priority });
+        insertSorted(this._weightedWaiters[weight - 1], { resolve: resolve2, priority });
       });
     }
   }
@@ -3945,11 +5285,11 @@ function findIndexFromEnd(a, predicate) {
 }
 var __awaiter$1 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve) {
-      resolve(value);
+    return value instanceof P ? value : new P(function(resolve2) {
+      resolve2(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve, reject) {
+  return new (P || (P = Promise))(function(resolve2, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -3965,7 +5305,7 @@ var __awaiter$1 = function(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -4203,7 +5543,6 @@ var ExportOrchestrator = class {
     if (!finalStore) {
       throw new Error("Analysis store not found. Scan the project first.");
     }
-    const bindings = await readActionBindings(this.projectRoot);
     for (const p of dossier.pillars) {
       p.decisions = p.decisions.filter((c) => !(c.severity === 1 && c.category === "Convention"));
       p.cardCount = p.decisions.length;
@@ -4211,12 +5550,17 @@ var ExportOrchestrator = class {
     const viewModel = this.buildViewModel(dossier, finalStore);
     const artifacts = [];
     artifacts.push(...await new JsonRenderer().render(viewModel, finalStore));
-    artifacts.push(...await new DeltaRenderer().render(viewModel, finalStore));
     artifacts.push(...await new ValidationRenderer().render(viewModel, finalStore));
     artifacts.push(...await new RawAnalysisRenderer().render(viewModel, finalStore));
     if (graph) {
       artifacts.push(...await new GraphRenderer(graph).render(viewModel, finalStore));
     }
+    const gateIndex = buildGateIndex(finalStore);
+    artifacts.push({
+      type: "gate",
+      path: "gate.json",
+      content: JSON.stringify(gateIndex, null, 2)
+    });
     const formats = ["html", "markdown"];
     if (options.format && options.format !== "json" && options.format !== "delta") {
       formats.length = 0;
@@ -4226,7 +5570,7 @@ var ExportOrchestrator = class {
       artifacts.push(...await new HtmlRenderer().render(viewModel, finalStore));
     }
     if (formats.includes("markdown")) {
-      artifacts.push(...await new AgentMarkdownRenderer(options.budget, bindings).render(viewModel, finalStore));
+      artifacts.push(...await new AgentMarkdownRenderer(options.budget).render(viewModel, finalStore));
     }
     const writer = new ArtifactBundleWriter(this.projectRoot);
     await writer.writeBundle(artifacts);
@@ -4333,8 +5677,8 @@ var ExportOrchestrator = class {
 
 // dist/export/Watcher.js
 import chokidar from "chokidar";
-import { createHash as createHash4 } from "crypto";
-import { readFile as readFile10 } from "fs/promises";
+import { createHash as createHash3 } from "crypto";
+import { readFile as readFile7 } from "fs/promises";
 import { join as join14 } from "path";
 var activeWatchers = /* @__PURE__ */ new Map();
 async function startWatcher(projectRoot, watchedPaths) {
@@ -4353,8 +5697,8 @@ async function startWatcher(projectRoot, watchedPaths) {
       const dossier = await readDossier(projectRoot);
       if (!dossier)
         return;
-      const content = await readFile10(filepath, "utf8");
-      const newHash = createHash4("sha256").update(content).digest("hex");
+      const content = await readFile7(filepath, "utf8");
+      const newHash = createHash3("sha256").update(content).digest("hex");
       let mutated = false;
       for (const pillar of dossier.pillars) {
         for (const card of pillar.decisions) {
@@ -4398,11 +5742,7 @@ var scanProjectTool = {
     required: ["projectRoot"]
   }
 };
-async function handleScanProject(args, options = {}) {
-  const projectRoot = args.projectRoot;
-  if (!projectRoot)
-    throw new Error("projectRoot is required");
-  console.error(`[vibe-splain] Scanning project: ${projectRoot}`);
+async function performScan(projectRoot, options = {}) {
   const result = await scanProject(projectRoot);
   const existing = await readDossier(projectRoot);
   const brief = existing?.map?.brief ?? null;
@@ -4435,16 +5775,22 @@ async function handleScanProject(args, options = {}) {
     budget: options.budget ? parseInt(options.budget, 10) : void 0,
     scope: options.scope
   }, result.store, result.graph, scanId);
-  await startWatcher(projectRoot, result.files.map((f) => f.path));
+  return { result, dossier, scanId, manifestPointer };
+}
+async function handleScanProject(args, options = {}) {
+  const projectRoot = args.projectRoot;
+  if (!projectRoot)
+    throw new Error("projectRoot is required");
+  console.error(`[vibe-splain] Scanning project: ${projectRoot}`);
+  const { result, scanId, manifestPointer } = await performScan(projectRoot, options);
+  if (options.watch !== false) {
+    await startWatcher(projectRoot, result.files.map((f) => f.path));
+  }
   console.error(`[vibe-splain] Scan complete. ${result.totalFilesScanned} files, ${result.realSourceCount} real-source, ${result.wildCandidates.length} wild candidates.`);
   const validation = result.validation ?? { passed: true, errors: 0, warnings: 0, reportPath: ".vibe-splainer/validation_report.json" };
-  let statusMsg = "Scan complete.";
-  if (!validation.passed) {
-    statusMsg = `SCAN QUALITY WARNING: ${validation.errors} errors and ${validation.warnings} warnings found in validation report. Delta Engine automation may be blocked.`;
-  }
   return {
     ok: true,
-    message: statusMsg,
+    message: "Scan complete.",
     scanId,
     manifestPointer,
     validation: result.fullValidationReport || {
@@ -4455,7 +5801,6 @@ async function handleScanProject(args, options = {}) {
     },
     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"
@@ -4560,7 +5905,7 @@ async function handleSetProjectBrief(args, options = {}) {
 }
 
 // dist/mcp/tools/get_file_context.js
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile8 } from "fs/promises";
 import { join as join15, relative as relative4, isAbsolute } from "path";
 var getFileContextTool = {
   name: "get_file_context",
@@ -4606,14 +5951,14 @@ async function handleGetFileContext(args) {
     smellSpans: evidence.smellSpans
   };
   if (full) {
-    result.source = await readFile11(fullPath, "utf8");
+    result.source = await readFile8(fullPath, "utf8");
   }
   return result;
 }
 
 // dist/mcp/tools/write_decision_card.js
-import { createHash as createHash5 } from "crypto";
-import { readFile as readFile12 } from "fs/promises";
+import { createHash as createHash4 } from "crypto";
+import { readFile as readFile9 } from "fs/promises";
 import { join as join16 } from "path";
 var CATEGORIES = ["Bottleneck", "Hack", "Smart-Move", "Risk", "Convention", "Dead-Weight"];
 function normalizeSnippet(s) {
@@ -4711,10 +6056,10 @@ async function handleWriteDecisionCard(args, options = {}) {
   const heat = persisted ? Math.round(persisted.heat) : void 0;
   let primaryContent = "";
   try {
-    primaryContent = await readFile12(join16(projectRoot, primaryFile), "utf8");
+    primaryContent = await readFile9(join16(projectRoot, primaryFile), "utf8");
   } catch {
   }
-  const hash = createHash5("sha256").update(primaryContent).digest("hex");
+  const hash = createHash4("sha256").update(primaryContent).digest("hex");
   const card = {
     id: v4_default(),
     pillar,
@@ -4941,57 +6286,8 @@ async function handleMarkStale(args, options = {}) {
   };
 }
 
-// dist/mcp/tools/get_call_chain.js
-var getCallChainTool = {
-  name: "get_call_chain",
-  description: `Trace how behavior is reached from an entrypoint by following function call edges through the codebase. Returns a step-by-step chain with exact function names, file paths, line numbers, action kinds, and evidence text. Every edge has a confidence level; unresolved edges are listed explicitly.
-
-Use structured filters when you know the target:
-  targetModel + targetOperation: "where does Booking get created?"
-  targetActionKind: "where is auth enforced?"  
-  targetFunctionName: "how is function X reached?"
-No filter returns the full call tree up to maxDepth.
-
-Run scan_project first \u2014 this tool reads from the generated action_bindings.json.`,
-  inputSchema: {
-    type: "object",
-    properties: {
-      projectRoot: { type: "string" },
-      entrypointPath: { type: "string", description: "Relative path to the entrypoint file" },
-      maxDepth: { type: "number", description: "Max traversal depth. Default 6, max 12." },
-      targetActionKind: { type: "string", description: "Stop at this semantic action kind." },
-      targetModel: { type: "string", description: "Stop at functions touching this model." },
-      targetOperation: { type: "string", description: "Narrow targetModel to this operation." },
-      targetFunctionName: { type: "string", description: "Stop at a specific function name." },
-      includeTests: { type: "boolean", description: "Include test files in traversal. Default false." }
-    },
-    required: ["projectRoot", "entrypointPath"]
-  }
-};
-async function handleGetCallChain(args) {
-  const projectRoot = args.projectRoot;
-  const entrypointPath = args.entrypointPath;
-  if (!projectRoot || !entrypointPath)
-    throw new Error("projectRoot and entrypointPath are required");
-  const getCallChainArgs = {
-    entrypointPath,
-    maxDepth: typeof args.maxDepth === "number" ? args.maxDepth : void 0,
-    targetActionKind: typeof args.targetActionKind === "string" ? args.targetActionKind : void 0,
-    targetModel: typeof args.targetModel === "string" ? args.targetModel : void 0,
-    targetOperation: typeof args.targetOperation === "string" ? args.targetOperation : void 0,
-    targetFunctionName: typeof args.targetFunctionName === "string" ? args.targetFunctionName : void 0,
-    includeTests: typeof args.includeTests === "boolean" ? args.includeTests : void 0
-  };
-  try {
-    const result = await traverseCallChain(projectRoot, getCallChainArgs);
-    return result;
-  } catch (error) {
-    throw new Error(`get_call_chain failed: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
 // dist/mcp/tools/get_file_skeleton.js
-import { readFile as readFile13 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 import { join as join17 } from "path";
 
 // ../../node_modules/balanced-match/dist/esm/index.js
@@ -6948,7 +8244,7 @@ async function handleGetFileSkeleton(args) {
       filePath
     };
   }
-  const source = await readFile13(absolutePath, "utf8");
+  const source = await readFile10(absolutePath, "utf8");
   const skeleton = extractSkeleton(source, filePath);
   const skeletonPayload = {
     filePath,
@@ -6999,7 +8295,7 @@ function extractSkeleton(source, filePath) {
 }
 
 // dist/mcp/tools/read_file.js
-import { readFile as readFile14 } from "fs/promises";
+import { readFile as readFile11 } from "fs/promises";
 import { join as join18 } from "path";
 var readFileTool = {
   name: "read_file",
@@ -7035,7 +8331,7 @@ async function handleReadFile(args) {
   const absolutePath = filePath.startsWith("/") ? filePath : join18(projectRoot, filePath);
   let content;
   try {
-    content = await readFile14(absolutePath, "utf8");
+    content = await readFile11(absolutePath, "utf8");
   } catch {
     throw new Error(`FileNotFound: cannot read ${filePath}`);
   }
@@ -7073,96 +8369,6 @@ async function handleReadFile(args) {
   return await applyBudgetGuard(projectRoot, scanId, "file_read", result);
 }
 
-// dist/mcp/tools/apply_patch.js
-import { writeFile as writeFile9, rename as rename3, mkdir as mkdir8 } from "fs/promises";
-import { join as join19, dirname as dirname4 } from "path";
-var StalePatchError = class extends Error {
-  filePath;
-  expectedHash;
-  actualHash;
-  constructor(filePath, expectedHash, actualHash) {
-    super(`StalePatchError: ${filePath} hash mismatch \u2014 expected ${expectedHash}, got ${actualHash}. File was modified since the expectedPrePatchHash was computed. Re-read the file and regenerate the patch.`);
-    this.filePath = filePath;
-    this.expectedHash = expectedHash;
-    this.actualHash = actualHash;
-    this.name = "StalePatchError";
-  }
-};
-var applyPatchTool = {
-  name: "apply_patch",
-  description: "Applies a text patch to a file within the active workOrder scope. Requires expectedPrePatchHash to prevent stale-patch corruption. Records pre- and post-patch hashes.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      projectRoot: { type: "string", description: "Absolute project root" },
-      filePath: { type: "string", description: "Path relative to projectRoot" },
-      newContent: { type: "string", description: "Full new content of the file after the patch" },
-      expectedPrePatchHash: {
-        type: "string",
-        description: "sha256:<hex> hash of the file BEFORE patching. Obtain via hashFile or the sourceHash from get_file_skeleton."
-      },
-      scanId: { type: "string", description: "Current scan ID for pointer registration" }
-    },
-    required: ["projectRoot", "filePath", "newContent", "expectedPrePatchHash", "scanId"]
-  }
-};
-async function handleApplyPatch(args) {
-  const projectRoot = args.projectRoot;
-  const filePath = args.filePath;
-  const newContent = args.newContent;
-  const expectedPrePatchHash = args.expectedPrePatchHash;
-  const scanId = args.scanId;
-  if (!projectRoot || !filePath || !newContent || !expectedPrePatchHash || !scanId) {
-    throw new Error("projectRoot, filePath, newContent, expectedPrePatchHash, and scanId are all required");
-  }
-  try {
-    SessionScope.enforce(filePath);
-  } catch (e) {
-    if (e instanceof ScopeViolation)
-      throw e;
-    throw e;
-  }
-  const absolutePath = filePath.startsWith("/") ? filePath : join19(projectRoot, filePath);
-  let actualPreHash;
-  try {
-    actualPreHash = await hashFile(absolutePath);
-  } catch {
-    actualPreHash = "sha256:new";
-  }
-  if (actualPreHash !== expectedPrePatchHash) {
-    throw new StalePatchError(filePath, expectedPrePatchHash, actualPreHash);
-  }
-  const dir = dirname4(absolutePath);
-  await mkdir8(dir, { recursive: true });
-  const tmpPath = absolutePath + `.tmp_${Date.now()}`;
-  await writeFile9(tmpPath, newContent, "utf8");
-  await rename3(tmpPath, absolutePath);
-  const postPatchHash = await hashFile(absolutePath);
-  const blobStore = new BlobStore(projectRoot);
-  const pointerStore = PointerStore.open(projectRoot);
-  const { blobPath } = await blobStore.writeAtomic(newContent);
-  const pointerId = `ptr_patch_${v4_default().replace(/-/g, "").slice(0, 12)}`;
-  await pointerStore.insertPointer({
-    pointerId,
-    scanId,
-    artifactName: "patch_record",
-    contentHash: postPatchHash,
-    blobPath,
-    schemaVersion: "1.0.0",
-    createdAt: Date.now(),
-    expiresAt: null
-  });
-  const result = {
-    ok: true,
-    filePath,
-    prePatchHash: actualPreHash,
-    postPatchHash,
-    pointerId,
-    message: `Patch applied to ${filePath}`
-  };
-  return await applyBudgetGuard(projectRoot, scanId, "patch_record", result);
-}
-
 // dist/mcp/tools/work_orders.js
 var createWorkOrderTool = {
   name: "create_work_order",
@@ -7288,97 +8494,6 @@ async function handleSpawnWorker(args) {
   };
 }
 
-// dist/mcp/tools/submit_receipt.js
-import { join as join20 } from "path";
-var submitReceiptTool = {
-  name: "submit_receipt",
-  description: "Worker submits a WorkerReceipt for a completed Work Order. The ProofValidator checks all 8 proof conditions. Returns accept/reject with detailed errors.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      projectRoot: { type: "string", description: "Absolute project root" },
-      receipt: {
-        type: "object",
-        description: "WorkerReceipt object",
-        properties: {
-          workOrderId: { type: "string" },
-          status: { type: "string", enum: ["completed", "failed", "blocked"] },
-          proofPointers: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                pointer: { type: "string" },
-                schemaName: { type: "string" },
-                contentHash: { type: "string" }
-              },
-              required: ["pointer", "schemaName", "contentHash"]
-            }
-          },
-          changedFiles: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                path: { type: "string" },
-                prePatchHash: { type: "string" },
-                postPatchHash: { type: "string" }
-              },
-              required: ["path", "prePatchHash", "postPatchHash"]
-            }
-          },
-          summary: { type: "string" }
-        },
-        required: ["workOrderId", "status", "proofPointers", "changedFiles", "summary"]
-      }
-    },
-    required: ["projectRoot", "receipt"]
-  }
-};
-async function handleSubmitReceipt(args) {
-  const projectRoot = args.projectRoot;
-  const receipt = args.receipt;
-  if (!projectRoot || !receipt) {
-    throw new Error("projectRoot and receipt are required");
-  }
-  const pointerStore = PointerStore.open(projectRoot);
-  const workOrder = pointerStore.getWorkOrder(receipt.workOrderId);
-  if (!workOrder) {
-    throw new Error(`WorkOrderNotFound: ${receipt.workOrderId}`);
-  }
-  if (workOrder.status !== "active") {
-    throw new Error(`WorkOrderNotActive: ${receipt.workOrderId} is "${workOrder.status}", expected "active"`);
-  }
-  const allowedFiles = JSON.parse(workOrder.allowedFiles);
-  const allowedGlobs = JSON.parse(workOrder.allowedGlobs);
-  const requiredProof = JSON.parse(workOrder.requiredProof);
-  const blobDir = join20(projectRoot, ".vibe-splainer", "blobs");
-  const isAllowedFile = (filePath) => {
-    const inExplicit = allowedFiles.some((f) => filePath === f || filePath.endsWith("/" + f) || filePath.endsWith(f));
-    const inGlobs = allowedGlobs.some((g) => minimatch(filePath, g, { matchBase: true }));
-    return inExplicit || inGlobs;
-  };
-  const validation = await ProofValidator.validate(receipt, requiredProof, isAllowedFile, blobDir);
-  const receiptId = `rcpt_${v4_default().replace(/-/g, "").slice(0, 16)}`;
-  const finalStatus = validation.valid ? receipt.status : "failed";
-  await pointerStore.insertReceipt({
-    receiptId,
-    workOrderId: receipt.workOrderId,
-    status: finalStatus,
-    proofPointers: receipt.proofPointers,
-    changedFiles: receipt.changedFiles,
-    summary: receipt.summary
-  });
-  await pointerStore.updateWorkOrderStatus(receipt.workOrderId, validation.valid ? receipt.status === "completed" ? "completed" : "failed" : "failed");
-  return {
-    receiptId,
-    accepted: validation.valid,
-    workOrderId: receipt.workOrderId,
-    validation,
-    finalStatus
-  };
-}
-
 // dist/mcp/tools/set_session_scope.js
 var setSessionScopeTool = {
   name: "set_session_scope",
@@ -7634,13 +8749,128 @@ async function handleGetEvidenceSlice(args) {
   return await applyBudgetGuard(projectRoot, scanId, "evidence_slice", result);
 }
 
+// dist/mcp/tools/prepareTaskContext.js
+import { join as join19 } from "path";
+import { readFile as readFile12, writeFile as writeFile8, mkdir as mkdir8 } from "fs/promises";
+var prepareTaskContextTool = {
+  name: "vibe_prepare_task_context",
+  description: "Prepares the ExpertNetworkPacket for a given task, selecting relevant files, routing to a specialist panel, analyzing risk warnings, and slicing scopes without running model inference.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      projectRoot: {
+        type: "string",
+        description: "Absolute path to the project root directory"
+      },
+      task: {
+        type: "string",
+        description: "Description of the task or issue to resolve"
+      },
+      files: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional list of files to explicitly focus on"
+      },
+      error_trace: {
+        type: "string",
+        description: "Optional error stack trace or exception output"
+      },
+      intended_behavior: {
+        type: "string",
+        description: "Optional description of the intended behavior"
+      },
+      max_files: {
+        type: "number",
+        description: "Optional maximum files to select"
+      }
+    },
+    required: ["projectRoot", "task"]
+  }
+};
+async function handlePrepareTaskContext(args, options = {}) {
+  const projectRoot = args.projectRoot;
+  const task = args.task;
+  const files = args.files;
+  const errorTrace = args.error_trace;
+  const intendedBehavior = args.intended_behavior;
+  const maxFiles = args.max_files;
+  if (!projectRoot)
+    throw new Error("projectRoot is required");
+  if (!task)
+    throw new Error("task is required");
+  console.error(`[vibe-splain] Preparing task context for task: "${task}"`);
+  let scanArtifact = null;
+  const artifactPath = join19(projectRoot, ".vibe-splainer", "analysis.json");
+  try {
+    const raw = await readFile12(artifactPath, "utf8");
+    scanArtifact = JSON.parse(raw);
+  } catch (err) {
+    console.error(`[vibe-splain] No scan artifact found at ${artifactPath}, proceeding with fallback routing.`);
+  }
+  const packet = buildExpertNetworkPacket({
+    task,
+    projectRoot,
+    scanArtifact,
+    files,
+    errorTrace,
+    intendedBehavior,
+    maxFiles
+  });
+  const networkDir = join19(projectRoot, ".vibe-splainer", "network");
+  const packetsDir = join19(networkDir, "packets");
+  try {
+    await mkdir8(packetsDir, { recursive: true });
+    const latestPath = join19(networkDir, "latest_packet.json");
+    await writeFile8(latestPath, JSON.stringify(packet, null, 2), "utf8");
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const timestampedPath = join19(packetsDir, `${timestamp}.json`);
+    await writeFile8(timestampedPath, JSON.stringify(packet, null, 2), "utf8");
+    console.error(`[vibe-splain] Network packets saved under ${networkDir}`);
+  } catch (err) {
+    console.error("[vibe-splain] Failed to save network packets locally:", err.message);
+  }
+  return {
+    ok: true,
+    packet
+  };
+}
+
+// dist/mcp/tools/explainSpecialistScope.js
+var explainSpecialistScopeTool = {
+  name: "vibe_explain_specialist_scope",
+  description: "Explains the jurisdiction scope card and profile definitions for a given specialist ID.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      specialist_id: {
+        type: "string",
+        description: "Specialist ID to explain (control_flow | data_transform | integration_contracts | generic_repo)"
+      }
+    },
+    required: ["specialist_id"]
+  }
+};
+async function handleExplainSpecialistScope(args, options = {}) {
+  const specialistId = args.specialist_id;
+  if (!specialistId)
+    throw new Error("specialist_id is required");
+  if (!isSpecialistId(specialistId)) {
+    throw new Error(`Invalid specialist ID: "${specialistId}". Must be one of: control_flow, data_transform, integration_contracts, generic_repo.`);
+  }
+  console.error(`[vibe-splain] Fetching scope profile for specialist: "${specialistId}"`);
+  const profile = getSpecialistProfile(specialistId);
+  return {
+    ok: true,
+    profile
+  };
+}
+
 // dist/mcp/server.js
 var ALL_TOOLS = [
   scanProjectTool,
   getProjectMapTool,
   setProjectBriefTool,
   getFileContextTool,
-  getCallChainTool,
   writeDecisionCardTool,
   getStrategicOverviewTool,
   inspectPillarTool,
@@ -7652,21 +8882,21 @@ var ALL_TOOLS = [
   getStartHereTool,
   getProjectSummaryTool,
   getEvidenceSliceTool,
-  // Phase 3: Delegation & Proof
+  // Phase 3: Worker Delegation
   createWorkOrderTool,
   spawnWorkerTool,
-  applyPatchTool,
-  submitReceiptTool,
   // Phase 4: Scope & Escalation
   setSessionScopeTool,
-  yieldForScopeExpansionTool
+  yieldForScopeExpansionTool,
+  // Specialist Network v0
+  prepareTaskContextTool,
+  explainSpecialistScopeTool
 ];
 var TOOL_HANDLERS = {
   scan_project: handleScanProject,
   get_project_map: handleGetProjectMap,
   set_project_brief: handleSetProjectBrief,
   get_file_context: handleGetFileContext,
-  get_call_chain: handleGetCallChain,
   write_decision_card: handleWriteDecisionCard,
   get_strategic_overview: handleGetStrategicOverview,
   inspect_pillar: handleInspectPillar,
@@ -7681,11 +8911,12 @@ var TOOL_HANDLERS = {
   // Phase 3
   create_work_order: handleCreateWorkOrder,
   spawn_worker: handleSpawnWorker,
-  apply_patch: handleApplyPatch,
-  submit_receipt: handleSubmitReceipt,
   // Phase 4
   set_session_scope: handleSetSessionScope,
-  yield_for_scope_expansion: handleYieldForScopeExpansion
+  yield_for_scope_expansion: handleYieldForScopeExpansion,
+  // Specialist Network v0
+  vibe_prepare_task_context: handlePrepareTaskContext,
+  vibe_explain_specialist_scope: handleExplainSpecialistScope
 };
 async function startMCPServer(options = {}) {
   await initParser2();
@@ -7811,204 +9042,239 @@ async function serveCommand(options) {
   await startMCPServer(options);
 }
 
-// dist/commands/export.js
-async function exportCommand(projectRoot, options) {
-  const root = projectRoot || process.cwd();
-  console.error(`[vibe-splain] Exporting dossier for ${root}`);
-  const dossier = await readDossier(root);
-  if (!dossier) {
-    console.error("[vibe-splain] Dossier not found. Run scan first.");
-    process.exit(1);
+// dist/commands/network.js
+import { join as join20, resolve } from "path";
+import { readFile as readFile13, writeFile as writeFile9, mkdir as mkdir9 } from "fs/promises";
+async function networkPlanCommand(task, options) {
+  const projectRoot = options.root ? resolve(options.root) : process.cwd();
+  const maxFiles = options.maxFiles ? parseInt(options.maxFiles, 10) : 8;
+  let scanArtifact = null;
+  const artifactPath = options.scanArtifact ? resolve(options.scanArtifact) : join20(projectRoot, ".vibe-splainer", "analysis.json");
+  try {
+    const raw = await readFile13(artifactPath, "utf8");
+    scanArtifact = JSON.parse(raw);
+  } catch (err) {
+    if (options.scanArtifact) {
+      console.error(`[vibe-splain] Error reading scan artifact at ${artifactPath}:`, err.message);
+    }
   }
-  const orchestrator = new ExportOrchestrator(root);
-  await orchestrator.writeBundle(dossier, {
-    format: options.format,
-    budget: options.budget ? parseInt(options.budget, 10) : void 0,
-    scope: options.scope
+  const packet = buildExpertNetworkPacket({
+    task,
+    projectRoot,
+    scanArtifact,
+    errorTrace: options.errorTrace,
+    intendedBehavior: options.intendedBehavior,
+    maxFiles
   });
-  console.error("[vibe-splain] Export complete.");
-}
-
-// dist/commands/gc.js
-import { join as join21 } from "path";
-import { rm as rm2, readdir as readdir2 } from "fs/promises";
-var DEFAULT_KEEP_SCANS = 3;
-async function gcCommand(projectRoot, opts = {}) {
-  const root = projectRoot ?? process.cwd();
-  const keepScans = opts.keepScans ?? DEFAULT_KEEP_SCANS;
-  console.error(`[vibe-splain gc] Running GC on ${root} (keeping last ${keepScans} scans)`);
-  const pointerStore = PointerStore.open(root);
-  const blobStore = new BlobStore(root);
-  const allScanIds = pointerStore.listAllScanIds();
-  console.error(`[vibe-splain gc] Found ${allScanIds.length} scans`);
-  const sorted = [...allScanIds].sort().reverse();
-  const keepIds = sorted.slice(0, keepScans);
-  const deleteIds = sorted.slice(keepScans);
-  if (deleteIds.length === 0) {
-    console.error("[vibe-splain gc] Nothing to collect");
-    return;
-  }
-  const keptPointers = keepIds.flatMap((id) => pointerStore.listPointersByScan(id));
-  const referencedBlobs = new Set(keptPointers.map((p) => p.blobPath));
-  const deleted = await pointerStore.gcScanPointers(keepIds);
-  console.error(`[vibe-splain gc] Deleted ${deleted} pointer rows`);
-  const allBlobs = await blobStore.listBlobPaths();
-  let blobsDeleted = 0;
-  for (const blobPath of allBlobs) {
-    if (!referencedBlobs.has(blobPath)) {
-      try {
-        await rm2(blobPath);
-        blobsDeleted++;
-      } catch {
+  const networkDir = join20(projectRoot, ".vibe-splainer", "network");
+  const packetsDir = join20(networkDir, "packets");
+  try {
+    await mkdir9(packetsDir, { recursive: true });
+    const latestPath = join20(networkDir, "latest_packet.json");
+    await writeFile9(latestPath, JSON.stringify(packet, null, 2), "utf8");
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const timestampedPath = join20(packetsDir, `${timestamp}.json`);
+    await writeFile9(timestampedPath, JSON.stringify(packet, null, 2), "utf8");
+    if (options.json) {
+      process.stdout.write(JSON.stringify(packet, null, 2) + "\n");
+    } else {
+      process.stdout.write("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+      process.stdout.write(" Vibe-Splain Specialist Network \u2014 Task Plan\n");
+      process.stdout.write("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+      process.stdout.write(`Task:               "${packet.task}"
+`);
+      process.stdout.write(`Project Root:       ${packet.projectRoot}
+`);
+      process.stdout.write(`Primary Specialist: ${packet.route.primarySpecialist}
+`);
+      process.stdout.write(`Panel:              ${packet.route.panel.join(", ")}
+`);
+      process.stdout.write(`Confidence:         ${packet.route.confidence}
+`);
+      process.stdout.write(`Reason:             ${packet.route.reason}
+`);
+      process.stdout.write("\nSelected Files:\n");
+      if (packet.selectedFiles.length > 0) {
+        packet.selectedFiles.forEach((f) => {
+          process.stdout.write(`  \u2022 ${f.path} [blastRadius: ${f.blastRadius}]
+`);
+          process.stdout.write(`    Reason: ${f.reason}
+`);
+        });
+      } else {
+        process.stdout.write("  (No files selected)\n");
+      }
+      process.stdout.write("\nRisk Warnings:\n");
+      if (packet.riskWarnings.length > 0) {
+        packet.riskWarnings.forEach((w) => {
+          const levelLabel = w.level === "critical" ? "\u{1F534} CRITICAL" : w.level === "warning" ? "\u{1F7E1} WARNING" : "\u2139\uFE0F INFO";
+          process.stdout.write(`  \u2022 [${levelLabel}] ${w.message}
+`);
+          process.stdout.write(`    Reason: ${w.reason}
+`);
+        });
+      } else {
+        process.stdout.write("  (No risks identified)\n");
       }
+      process.stdout.write("\nSmallest Safe Change Policy:\n");
+      process.stdout.write(`  ${packet.smallestSafeChangePolicy.summary}
+`);
+      process.stdout.write("\nSaved Artifacts:\n");
+      process.stdout.write(`  \u2022 Latest: ${latestPath}
+`);
+      process.stdout.write(`  \u2022 Packet: ${timestampedPath}
+`);
+      process.stdout.write("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
     }
-  }
-  console.error(`[vibe-splain gc] Deleted ${blobsDeleted} unreferenced blobs`);
-  const tmpDir = join21(root, ".vibe-splainer", "tmp");
-  try {
-    const tmpFiles = await readdir2(tmpDir);
-    for (const f of tmpFiles) {
-      await rm2(join21(tmpDir, f), { force: true });
+  } catch (err) {
+    console.error("[vibe-splain] Error saving network artifacts:", err.message);
+    if (options.json) {
+      process.stdout.write(JSON.stringify(packet, null, 2) + "\n");
     }
-    console.error(`[vibe-splain gc] Cleaned ${tmpFiles.length} tmp files`);
-  } catch {
   }
-  console.error("[vibe-splain gc] Done");
 }
 
-// dist/commands/bundle.js
-import { join as join22 } from "path";
-import { writeFile as writeFile10, mkdir as mkdir9, copyFile, rm as rm3 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
-import * as tar from "tar";
-async function bundleCommand(scanId, opts = {}) {
-  const root = opts.projectRoot ?? process.cwd();
-  const outputPath = opts.output ?? join22(root, `vibe-bundle-${scanId}.tar.gz`);
-  console.error(`[vibe-splain bundle] Bundling scan ${scanId} from ${root}`);
-  const pointerStore = PointerStore.open(root);
-  const blobStore = new BlobStore(root);
-  const pointers = pointerStore.listPointersByScan(scanId);
-  if (pointers.length === 0) {
-    throw new Error(`No pointers found for scanId "${scanId}"`);
-  }
-  const stagingDir = join22(root, ".vibe-splainer", "tmp", `bundle-stage-${scanId}`);
-  const blobsStageDir = join22(stagingDir, "blobs");
-  await mkdir9(blobsStageDir, { recursive: true });
-  try {
-    const bundleManifest = {
-      schemaVersion: "1.0.0",
-      scanId,
-      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      projectRoot: root,
-      pointers: pointers.map((p) => ({
-        pointerId: p.pointerId,
-        scanId: p.scanId,
-        artifactName: p.artifactName,
-        contentHash: p.contentHash,
-        blobFile: `blobs/${p.contentHash.replace("sha256:", "sha256_")}`,
-        schemaVersion: p.schemaVersion,
-        createdAt: p.createdAt,
-        expiresAt: p.expiresAt
-      }))
+// dist/commands/hook.js
+import { existsSync as existsSync7, writeFileSync, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname5, join as join21 } from "path";
+import { tmpdir } from "os";
+
+// dist/hook/preToolUse.js
+var DEFER = { action: "defer" };
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit"]);
+function decidePreToolUse(input, gateIndex, sessionState) {
+  if (!EDIT_TOOLS.has(input.tool_name ?? ""))
+    return DEFER;
+  if (!gateIndex) {
+    if (sessionState && !sessionState.warningShown) {
+      const warnMsg = "vibe-splain: .vibe-splainer/gate.json is missing. Please run 'vibe-splain scan' to generate the scan architecture and enable tool guarding.";
+      return {
+        action: "emit",
+        output: {
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: "allow",
+            additionalContext: warnMsg,
+            systemMessage: warnMsg
+          }
+        }
+      };
+    }
+    return DEFER;
+  }
+  const filePath = input.tool_input?.file_path;
+  if (!filePath)
+    return DEFER;
+  const ctx = buildEscalationContext(filePath, gateIndex);
+  if (!ctx || ctx.blastRadius === "low")
+    return DEFER;
+  const block = formatEscalation(ctx);
+  if (ctx.blastRadius === "high") {
+    return {
+      action: "emit",
+      output: {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "ask",
+          permissionDecisionReason: block,
+          additionalContext: block
+        }
+      }
     };
-    await writeFile10(join22(stagingDir, "bundle-manifest.json"), JSON.stringify(bundleManifest, null, 2), "utf8");
-    const seen = /* @__PURE__ */ new Set();
-    for (const p of pointers) {
-      const hex = p.contentHash.replace("sha256:", "");
-      if (seen.has(hex))
-        continue;
-      seen.add(hex);
-      const srcPath = p.blobPath;
-      if (!existsSync7(srcPath)) {
-        console.error(`[vibe-splain bundle] Warning: blob missing for ${p.pointerId}: ${srcPath}`);
-        continue;
+  }
+  return {
+    action: "emit",
+    output: {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "allow",
+        additionalContext: block
       }
-      await copyFile(srcPath, join22(blobsStageDir, `sha256_${hex}`));
     }
-    await tar.create({
-      gzip: true,
-      file: outputPath,
-      cwd: stagingDir,
-      portable: true
-    }, ["."]);
-    console.error(`[vibe-splain bundle] Bundle written: ${outputPath}`);
-    console.error(`[vibe-splain bundle] ${pointers.length} pointers, ${seen.size} blobs`);
-  } finally {
-    await rm3(stagingDir, { recursive: true, force: true });
-  }
+  };
+}
+function formatEscalation(ctx) {
+  const lines = [];
+  lines.push(`vibe-splain: ${ctx.blastRadius} blast radius \u2014 ${ctx.targetFile} (gravity ${ctx.gravity}).`);
+  if (ctx.dependentCount > 0) {
+    const shown = ctx.dependents.slice(0, 8);
+    const more = ctx.dependentCount - shown.length;
+    lines.push(`${ctx.dependentCount} file(s) depend on it:`);
+    for (const d of shown)
+      lines.push(`  - ${d}`);
+    if (more > 0)
+      lines.push(`  \u2026 (+${more} more)`);
+  }
+  for (const w of ctx.riskWarnings)
+    lines.push(`[${w.level}] ${w.message}`);
+  lines.push(ctx.smallestSafeChange.summary);
+  return lines.join("\n");
 }
 
-// dist/commands/importBundle.js
-import { join as join23 } from "path";
-import { readFile as readFile15, mkdir as mkdir10, rm as rm4 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
-import * as tar2 from "tar";
-import { createHash as createHash6 } from "crypto";
-async function importBundleCommand(tarballPath, opts = {}) {
-  const root = opts.projectRoot ?? process.cwd();
-  const namespace = opts.namespace ?? `imported_${Date.now()}`;
-  console.error(`[vibe-splain import] Importing ${tarballPath} into ${root} (namespace: ${namespace})`);
-  if (!existsSync8(tarballPath)) {
-    throw new Error(`Tarball not found: ${tarballPath}`);
-  }
-  const extractDir = join23(root, ".vibe-splainer", "tmp", `import-${namespace}`);
-  await mkdir10(extractDir, { recursive: true });
+// dist/commands/hook.js
+function findProjectRoot(start) {
+  let dir = start || process.cwd();
+  for (let i = 0; i < 64; i++) {
+    if (existsSync7(join21(dir, ".vibe-splainer", "analysis.json")))
+      return dir;
+    const parent = dirname5(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+async function runHookCommand(rawStdin) {
+  let input;
   try {
-    await tar2.extract({
-      file: tarballPath,
-      cwd: extractDir
-    });
-    const manifestPath = join23(extractDir, "bundle-manifest.json");
-    if (!existsSync8(manifestPath)) {
-      throw new Error("Invalid bundle: missing bundle-manifest.json");
-    }
-    const manifestRaw = await readFile15(manifestPath, "utf8");
-    const manifest = JSON.parse(manifestRaw);
-    if (manifest.schemaVersion !== "1.0.0") {
-      throw new Error(`Unsupported bundle schema version: ${manifest.schemaVersion}`);
-    }
-    const blobStore = new BlobStore(root);
-    const pointerStore = PointerStore.open(root);
-    await blobStore.ensureDirs();
-    let imported = 0;
-    let hashErrors = 0;
-    for (const entry of manifest.pointers) {
-      const blobSrcPath = join23(extractDir, entry.blobFile);
-      if (!existsSync8(blobSrcPath)) {
-        console.error(`[vibe-splain import] Missing blob for pointer ${entry.pointerId}: ${entry.blobFile}`);
-        hashErrors++;
-        continue;
-      }
-      const content = await readFile15(blobSrcPath);
-      const actualHash = `sha256:${createHash6("sha256").update(content).digest("hex")}`;
-      if (actualHash !== entry.contentHash) {
-        console.error(`[vibe-splain import] Hash mismatch for ${entry.pointerId}: expected ${entry.contentHash}, got ${actualHash}`);
-        hashErrors++;
-        continue;
-      }
-      const { blobPath } = await blobStore.writeAtomic(content);
-      const namespacedPointerId = `${namespace}::${entry.pointerId}`;
-      const namespacedScanId = `${namespace}::${entry.scanId}`;
-      await pointerStore.insertPointer({
-        pointerId: namespacedPointerId,
-        scanId: namespacedScanId,
-        artifactName: entry.artifactName,
-        contentHash: entry.contentHash,
-        blobPath,
-        schemaVersion: entry.schemaVersion,
-        createdAt: entry.createdAt,
-        expiresAt: entry.expiresAt
-      });
-      imported++;
+    input = JSON.parse(rawStdin);
+  } catch {
+    return { stdout: null };
+  }
+  const root = findProjectRoot(input.cwd);
+  const gatePath = root ? join21(root, ".vibe-splainer", "gate.json") : null;
+  const gateExists = gatePath ? existsSync7(gatePath) : false;
+  let gateIndex = null;
+  if (gateExists) {
+    try {
+      gateIndex = JSON.parse(readFileSync3(gatePath, "utf8"));
+    } catch {
     }
-    if (hashErrors > 0) {
-      console.error(`[vibe-splain import] Warning: ${hashErrors} blobs failed hash verification and were skipped`);
+  }
+  const sessionId = input.session_id || "default";
+  const warnFile = join21(tmpdir(), `vibe-splain-warn-${sessionId}`);
+  const warningShown = existsSync7(warnFile);
+  const result = decidePreToolUse(input, gateIndex, { warningShown });
+  if (result.action === "defer")
+    return { stdout: null };
+  if (!gateIndex && result.action === "emit") {
+    try {
+      writeFileSync(warnFile, "1");
+    } catch {
     }
-    console.error(`[vibe-splain import] Imported ${imported}/${manifest.pointers.length} pointers under namespace "${namespace}"`);
-    console.error(`[vibe-splain import] Original scanId: ${manifest.scanId} \u2192 namespaced as: ${namespace}::${manifest.scanId}`);
-  } finally {
-    await rm4(extractDir, { recursive: true, force: true });
   }
+  return { stdout: JSON.stringify(result.output) };
+}
+async function hookPreToolUseCommand() {
+  const raw = await readStdin();
+  const { stdout } = await runHookCommand(raw);
+  if (stdout)
+    process.stdout.write(stdout);
+}
+function readStdin() {
+  return new Promise((resolve2) => {
+    let data = "";
+    if (process.stdin.isTTY) {
+      resolve2("");
+      return;
+    }
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve2(data));
+    process.stdin.on("error", () => resolve2(data));
+  });
 }
 
 // dist/index.js
@@ -8016,23 +9282,8 @@ var program = new Command();
 program.name("vibe-splain").description("Architectural dossier engine for vibe-coded projects").version("3.4.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)").option("--format <format>", "Export format (html, markdown, etc.)").option("--budget <budget>", "Token budget for markdown").option("--scope <scope>", "Scope for export").action((options) => serveCommand(options));
-program.command("export [projectRoot]").description("Manually trigger bundle generation").option("--format <format>", "Export format (html, markdown, etc.)").option("--budget <budget>", "Token budget for markdown").option("--scope <scope>", "Scope for export").action(exportCommand);
-program.command("gc [projectRoot]").description("Garbage-collect old scan artifacts, keeping the last N scans").option("--keep-scans <n>", "Number of scans to keep (default: 3)", "3").action((projectRoot, options) => {
-  gcCommand(projectRoot, { keepScans: parseInt(options.keepScans, 10) }).catch((err) => {
-    console.error("[vibe-splain gc] Error:", err.message);
-    process.exit(1);
-  });
-});
-program.command("bundle <scanId>").description("Bundle a scan into a portable vibe-bundle.tar.gz").option("--output <path>", "Output tarball path").option("--project-root <path>", "Project root (default: cwd)").action((scanId, options) => {
-  bundleCommand(scanId, { output: options.output, projectRoot: options.projectRoot }).catch((err) => {
-    console.error("[vibe-splain bundle] Error:", err.message);
-    process.exit(1);
-  });
-});
-program.command("import <tarball>").description("Import a vibe-bundle.tar.gz into the local pointer store").option("--namespace <ns>", "Bundle namespace alias (default: imported_<timestamp>)").option("--project-root <path>", "Project root (default: cwd)").action((tarball, options) => {
-  importBundleCommand(tarball, { namespace: options.namespace, projectRoot: options.projectRoot }).catch((err) => {
-    console.error("[vibe-splain import] Error:", err.message);
-    process.exit(1);
-  });
-});
+var networkCmd = program.command("network").description("Manage specialist network adapters and tasks");
+networkCmd.command("plan <task>").description("Build and route an Expert Network packet for a given task").option("--root <path>", "Alternative project root path").option("--scan-artifact <path>", "Custom path to a scan artifact (.vibe-splainer/analysis.json)").option("--json", "Print the compiled ExpertNetworkPacket as JSON").option("--max-files <number>", "Maximum files to select").option("--error-trace <string>", "Optional error trace or stack details").option("--intended-behavior <string>", "Optional intended behavior description").action((task, options) => networkPlanCommand(task, options));
+var hookCmd = program.command("hook").description("Deterministic agent hooks (called by your coding agent, not by you)");
+hookCmd.command("pretooluse").description("PreToolUse gate: escalate edits to high-blast-radius files").action(() => hookPreToolUseCommand());
 program.parse();