@vibgrate/cli 2026.801.1 → 2026.803.3

package/dist/cli.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
-import { loadAdvancedScanHook, baselineCommand } from './chunk-FF5ZQ6KI.js';
-import { fetchCatalog, resolveProviders } from './chunk-JLWI2JGA.js';
-import { VGD_PROTOCOL_VERSION, startVgdServer } from './chunk-V2QK3IUY.js';
-import { telemetryOptOut, StatsSharer, statsEndpoint, isCI } from './chunk-B3OMGYZZ.js';
+import { loadAdvancedScanHook, baselineCommand } from './chunk-6JP7HGIF.js';
+import { fetchCatalog, resolveProviders } from './chunk-NUZM7UOR.js';
+import { VGD_PROTOCOL_VERSION, startVgdServer } from './chunk-L5PUNO3T.js';
+import { telemetryOptOut, StatsSharer, statsEndpoint, isCI } from './chunk-PXM3VZYR.js';
+import './chunk-7AVYKZEM.js';
 import { buildModelInstallPlan } from './chunk-WHJMS7XC.js';
-import { runCodeSession } from './chunk-WIDZ5IE7.js';
-import { sha256Hex, generateKeypair, dssePae, DSSE_PAYLOAD_TYPE, keyId, registerBuild, readGlobal, applyGlobalOptions, ProgressBar, printLogo, runBuild } from './chunk-XEJJGDGX.js';
-export { runBuild } from './chunk-XEJJGDGX.js';
+import { runCodeSession } from './chunk-M7773OUN.js';
+import { sha256Hex, generateKeypair, dssePae, DSSE_PAYLOAD_TYPE, keyId, registerBuild, readGlobal, applyGlobalOptions, ProgressBar, printLogo, runBuild } from './chunk-KYX2YCXT.js';
+export { runBuild } from './chunk-KYX2YCXT.js';
 import { disableColor, info, c, json, out } from './chunk-CT5BS56U.js';
-import './chunk-5I4VSBWQ.js';
 import './chunk-IS7VTH2Q.js';
 import { init_resolve_ollama, gatherSystemMemory, resolveOllamaBinary, hasOllamaBinary, resolve_ollama_exports } from './chunk-OWSFZQOP.js';
 import { readOrchestratorState, writeOrchestratorState, parseMode, setDefaultMode, recommendMode, activePin, resolveMode, providerForBackend, QUALIFIED_PACKS, pinPack, unpinPack, buildOrchestratorStatus } from './chunk-NZELMYT4.js';
@@ -16,54 +16,55 @@ import { fmt, estimateModelBytes } from './chunk-7N4Y3E47.js';
 import './chunk-IZDH67DX.js';
 import { defaultProcessEndpoint, startProcessHostServer, resolveInferenceIsolation } from './chunk-JFE7XCAE.js';
 import { clearHostSessionPool, acquireHostSession, generateOnSession, listHostSessions, hostSessionPoolSize } from './chunk-3LOWJSAF.js';
-import { CONTEXT_POLICY_VERSION, computeFcsReport, renderFcsReportMarkdown, createTrajectoryCollector, runAgent } from './chunk-IRCYOTRG.js';
+import { CONTEXT_POLICY_VERSION, computeFcsReport, renderFcsReportMarkdown, createTrajectoryCollector, runAgent } from './chunk-WGPS3NZQ.js';
 import './chunk-543E6WDJ.js';
-import { summarizeDiffs, ScriptedProvider } from './chunk-G25STLE7.js';
+import { summarizeDiffs, ScriptedProvider } from './chunk-SJFBXCII.js';
 import { ensurePackage, ensureUnavailableMessage } from './chunk-REIGWTTH.js';
-import './chunk-A43I2AJ4.js';
+import './chunk-TM5XQY3L.js';
 import { vgdSocketPath, vgdIsRunning, vgdRequest, vgdPidPath } from './chunk-RBIRXQR6.js';
 import { buildIdentifierTrieFromGraph } from './chunk-5HYCB55P.js';
-import './chunk-7AVYKZEM.js';
-import { serveStdio, exportGraph, GraphSource, createServer, formatForExt } from './chunk-BNEHDLVZ.js';
-import { refreshIfStale } from './chunk-V3X3DBZL.js';
-import { CliError, ExitCode, driftCount, ASSISTANTS, detectAssistants, isAssistantInstalled, usageError, detectServeLaunch, installAssistant, writeNavigationConfig, uninstallAssistant, buildGraph, writeSnapshot, probeFreshness, discover, assistantById, SMALL_REPO_FILES, isSkippedDirName, SKIP_FILES, SKIP_DIRS } from './chunk-KL65SSR7.js';
-import { resolveDsn, createWorkspaceDsn, writeStoredCredentials, credentialsPath, findGitRoot, ensureGitignored, gitignoreEntryForCredentials, clearStoredCredentials, parseDsn as parseDsn$1, uploadScanArtifact, dsnCommand, pushCommand, countTokens, shortestPath, pathDisconnect, testsToRun, detectRunner, coveringTests, FREE_PACK, readScanArtifact, publishPrivateLibrary, assessDocQuality, symbolsFromApi, fetchHostedDocsCached, selectForBudget, hostedBase, readStoredCredentials, projectCredentialsPath, homeCredentialsPath } from './chunk-7PVCHLR2.js';
-import { writeDefaultConfig, parseDsn, detectVcs, computeRepoFingerprint, resolveRepositoryName, fetchScanPreflight, runCoreScan, loadConfig, prepareCompressedUpload, computeDriftScore, titleBox, projectTypeToVulnEcosystem, driftBar, gitHistoryAvailable, buildVersionTimelines, findPackageAnyEcosystem, normalizeConstraint, findVersionCrossings, versionSatisfies, PROJECT_TYPE_TO_OSV_ECOSYSTEM, fetchRiskySymbols, perDependencyDrift } from './chunk-XRN7DQGR.js';
+import { serveStdio, isRelevantChange, exportGraph, GraphSource, createServer, formatForExt } from './chunk-NSWEJPLV.js';
+import { refreshIfStale } from './chunk-UXR7FBE3.js';
+import { CliError, ExitCode, driftCount, ASSISTANTS, detectAssistants, isAssistantInstalled, usageError, detectServeLaunch, installAssistant, writeNavigationConfig, uninstallAssistant, buildGraph, writeSnapshot, probeFreshness, discover, assistantById, SMALL_REPO_FILES, isSkippedDirName, SKIP_FILES, SKIP_DIRS } from './chunk-TNADGCOX.js';
+import { resolveDsn, createWorkspaceDsn, writeStoredCredentials, credentialsPath, findGitRoot, ensureGitignored, gitignoreEntryForCredentials, clearStoredCredentials, parseDsn as parseDsn$1, uploadScanArtifact, dsnCommand, pushCommand, countTokens, shortestPath, pathDisconnect, testsToRun, detectRunner, coveringTests, FREE_PACK, readScanArtifact, publishPrivateLibrary, assessDocQuality, symbolsFromApi, fetchHostedDocsCached, selectForBudget, hostedBase, readStoredCredentials, projectCredentialsPath, homeCredentialsPath } from './chunk-M452MRWI.js';
+import { writeDefaultConfig, parseDsn, detectVcs, computeRepoFingerprint, resolveRepositoryName, fetchScanPreflight, runCoreScan, loadConfig, prepareCompressedUpload, computeDriftScore, titleBox, projectTypeToVulnEcosystem, driftBar, gitHistoryAvailable, buildVersionTimelines, findPackageAnyEcosystem, normalizeConstraint, findVersionCrossings, versionSatisfies, PROJECT_TYPE_TO_OSV_ECOSYSTEM, fetchRiskySymbols, perDependencyDrift } from './chunk-NJFQCDGA.js';
 import { resolveIngestHost, dashHostForIngestHost, availableRegionIds, ingestHostForRegionId } from './chunk-HTLDXEHW.js';
+import { discoverModels } from './chunk-CQDUBAQY.js';
+import { freeBytesOnVolume, weightStoreDir, listCachedWeights, ensureWeightCached, catalogIntegrityReport } from './chunk-OV4KGXPD.js';
+import { pathExists as pathExists$1, parseExcludePatterns } from './chunk-DT4KIVRI.js';
 import { ensureDir, pathExists, readJsonFile, writeTextFile, writeJsonFile } from './chunk-CRAMOEBE.js';
-import { recordCliCall, CLI_TOOL_ALIASES, savingsLedgerPath, clearSavings, readSavings, readUsage, readModelSavings, CAPSULE_RANKING_VERSION, SAVINGS_TOOLS, sanitizeClient } from './chunk-MPP4S4OE.js';
-import './chunk-IPICO2RV.js';
-import { inventory, enrichOnline, ECOSYSTEMS, catalogPath, libDir, loadCatalog, driftFor, addLibrary, resolveLib, libId, resolveVersion, readDoc, localPackageDocs, localApiSurface } from './chunk-I6RBAIS3.js';
+import { recordCliCall, CLI_TOOL_ALIASES, savingsLedgerPath, clearSavings, readSavings, readUsage, readModelSavings, CAPSULE_RANKING_VERSION, SAVINGS_TOOLS, sanitizeClient } from './chunk-K6Q6HTFD.js';
+import './chunk-VIWZ4QT7.js';
+import { inventory, enrichOnline, ECOSYSTEMS, catalogPath, libDir, loadCatalog, driftFor, addLibrary, resolveLib, libId, resolveVersion, readDoc, localPackageDocs, localApiSurface } from './chunk-XK5LKOBF.js';
 import { init_cli_invocation, resolveCliInvocation, NPX_INVOCATION } from './chunk-3LSG7Z4I.js';
 import { resolveOne } from './chunk-J7LKEB2R.js';
-import { embeddingsCached, resolveEmbedModel, loadEmbedder, getNodeEmbeddings, queryGraphSemantic, queryGraph, unavailableMessage, countPending, indexFor, impactOf, modelCacheInfo, clearModelCache } from './chunk-SDG242R4.js';
-import { discoverModels } from './chunk-CQDUBAQY.js';
-import { freeBytesOnVolume, weightStoreDir, listCachedWeights, ensureWeightCached, catalogIntegrityReport } from './chunk-OV4KGXPD.js';
+import { embeddingsCached, resolveEmbedModel, loadEmbedder, getNodeEmbeddings, queryGraphSemantic, queryGraph, unavailableMessage, countPending, indexFor, impactOf, modelCacheInfo, clearModelCache, withTimeout } from './chunk-HC44772H.js';
 import { resolvedGrammarFiles, grammarSetVersion } from './chunk-UTNNGKKX.js';
 import './chunk-RXP66R2E.js';
-import { loadGraph, SCHEMA_VERSION } from './chunk-T6DRYOMT.js';
-import { resolveGraphPath, renderReport, loadGraphFileWithSnapshot, writeArtifacts, vibgrateDir, mapFileExists, ensureVibgrateGitignore } from './chunk-76TDXGGF.js';
-import { VERSION } from './chunk-TGDHOAXX.js';
-import { cacheDir, serializeGraph, stableStringify } from './chunk-ZKNB4YH4.js';
+import { loadGraph, loadGraphPreferIndex, SCHEMA_VERSION } from './chunk-CPLG4GFB.js';
+import { resolveGraphPath, analyzeQuestion, loadTopicTags, renderReport, resetRelevanceProviderCache, loadRelevanceProvider, loadGraphFileWithSnapshot, writeArtifacts, vibgrateDir, mapFileExists, relevanceModuleDir, ensureVibgrateGitignore } from './chunk-3Q3ZXJZP.js';
+import { VERSION } from './chunk-7KNFG44U.js';
+import { cacheDir, serializeGraph, stableStringify, parseGraph } from './chunk-QMME6TB4.js';
+import './chunk-5I4VSBWQ.js';
 import './chunk-BWPBB45M.js';
 import { canonicalize, hashString, hashBytes } from './chunk-JFGYT6BI.js';
 import './chunk-BPF3YX2U.js';
-import { pathExists as pathExists$1, parseExcludePatterns } from './chunk-DT4KIVRI.js';
 import { __toCommonJS } from './chunk-Z6ZWNWWR.js';
-import * as fs7 from 'fs';
-import fs7__default, { realpathSync } from 'fs';
-import * as path37 from 'path';
-import path37__default from 'path';
+import * as fs10 from 'fs';
+import fs10__default, { realpathSync } from 'fs';
+import * as path39 from 'path';
+import path39__default from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { Command, CommanderError, Option } from 'commander';
 import * as semver3 from 'semver';
 import semver3__default from 'semver';
-import { execSync, spawn, spawnSync, execFileSync } from 'child_process';
 import * as readline from 'readline';
+import * as zlib from 'zlib';
 import * as crypto3 from 'crypto';
-import { randomUUID } from 'crypto';
+import { randomUUID, createHash } from 'crypto';
+import { execSync, spawn, spawnSync, execFileSync } from 'child_process';
 import chalk7 from 'chalk';
-import * as fs21 from 'fs/promises';
+import * as fs24 from 'fs/promises';
 import * as os from 'os';
 
 init_cli_invocation();
@@ -74,10 +75,10 @@ function registerStatus(program) {
   applyGlobalOptions(cmd);
 }
 async function runStatus(global) {
-  const root2 = path37.resolve(global.cwd ?? ".");
+  const root2 = path39.resolve(global.cwd ?? ".");
   const graphPath = resolveGraphPath(root2, global.graph);
   const graph = loadGraph(root2, graphPath);
-  const hasCache = fs7.existsSync(path37.join(cacheDir(root2), "parse-cache.json"));
+  const hasCache = fs10.existsSync(path39.join(cacheDir(root2), "parse-cache.json"));
   let stale = null;
   let staleExact = false;
   if (graph) {
@@ -97,8 +98,8 @@ async function runStatus(global) {
   }
   if (global.json) {
     json({
-      root: path37.relative(process.cwd(), root2) || ".",
-      graphPath: path37.relative(root2, graphPath),
+      root: path39.relative(process.cwd(), root2) || ".",
+      graphPath: path39.relative(root2, graphPath),
       built: graph !== null,
       generatedAt: graph?.generatedAt ?? null,
       counts: graph?.meta.counts ?? null,
@@ -113,11 +114,11 @@ async function runStatus(global) {
     return;
   }
   if (!graph) {
-    info(`${c.cyan("vg")} \xB7 no map yet at ${c.dim(path37.relative(root2, graphPath))}`);
+    info(`${c.cyan("vg")} \xB7 no map yet at ${c.dim(path39.relative(root2, graphPath))}`);
     info(`  run ${c.bold("vg")} to build one`);
     return;
   }
-  info(`${c.cyan("vg")} \xB7 ${path37.relative(root2, graphPath)}`);
+  info(`${c.cyan("vg")} \xB7 ${path39.relative(root2, graphPath)}`);
   info(`  generated ${graph.generatedAt}`);
   info(
     `  nodes ${c.bold(String(graph.meta.counts.nodes))}  edges ${c.bold(
@@ -134,7 +135,7 @@ async function runStatus(global) {
   if (vibgrateDir(root2)) ;
 }
 function rootOf(global) {
-  return path37.resolve(global.cwd ?? ".");
+  return path39.resolve(global.cwd ?? ".");
 }
 function requireGraph(global) {
   const root2 = rootOf(global);
@@ -170,6 +171,8 @@ function registerAsk(program) {
     let result;
     let mode = "lexical";
     let note = "";
+    const relevance = await analyzeQuestion(q);
+    const topicTags = relevance ? await loadTopicTags(graph, root2, resolveGraphPath(root2, global.graph)) : null;
     if (wantSemantic) {
       const firstRun = !embeddingsCached(root2, resolveEmbedModel());
       if (!global.json && firstRun) {
@@ -181,14 +184,14 @@ function registerAsk(program) {
         const bar = !global.json && firstRun ? new ProgressBar(c.dim("embedding")) : void 0;
         const vectors = await getNodeEmbeddings(graph, embedder, root2, bar ? (d, t) => bar.update(d, t) : void 0);
         bar?.done();
-        result = await queryGraphSemantic(graph, q, { budget, embedder, nodeVectors: vectors });
+        result = await queryGraphSemantic(graph, q, { budget, embedder, nodeVectors: vectors, relevance, topicTags });
         mode = `semantic (${embedder.id})`;
       } else {
-        result = queryGraph(graph, q, { budget });
+        result = queryGraph(graph, q, { budget, relevance, topicTags });
         note = reason ? unavailableMessage(reason) : "semantic unavailable; used lexical";
       }
     } else {
-      result = queryGraph(graph, q, { budget });
+      result = queryGraph(graph, q, { budget, relevance, topicTags });
       if (global.local) note = "semantic skipped under --local; used lexical";
     }
     if (global.client) {
@@ -868,12 +871,12 @@ var PUBLISH_INTERVAL_MS = 2e3;
 var KEEPALIVE_MS = 1e4;
 var STALE_MS = 6e4;
 function liveStatsDir(root2) {
-  return path37.join(cacheDir(root2), "serve-live");
+  return path39.join(cacheDir(root2), "serve-live");
 }
 function reapOtherVersionServers(dir, keepVersion, now = Date.now(), kill = (pid, signal) => process.kill(pid, signal), selfPid = process.pid) {
   let entries;
   try {
-    entries = fs7.readdirSync(dir);
+    entries = fs10.readdirSync(dir);
   } catch {
     return [];
   }
@@ -882,7 +885,7 @@ function reapOtherVersionServers(dir, keepVersion, now = Date.now(), kill = (pid
     if (!/^serve-\d+\.json$/.test(name)) continue;
     let parsed;
     try {
-      parsed = JSON.parse(fs7.readFileSync(path37.join(dir, name), "utf8"));
+      parsed = JSON.parse(fs10.readFileSync(path39.join(dir, name), "utf8"));
     } catch {
       continue;
     }
@@ -904,7 +907,7 @@ var LiveStatsBus = class {
     this.dir = dir;
     this.stats = stats;
     this.pid = pid;
-    this.file = path37.join(dir, `serve-${this.pid}.json`);
+    this.file = path39.join(dir, `serve-${this.pid}.json`);
   }
   dir;
   stats;
@@ -936,10 +939,10 @@ var LiveStatsBus = class {
     this.lastWriteAt = now;
     const body = { pid: this.pid, updatedAt: now, version: VERSION, snapshot: snap };
     try {
-      fs7.mkdirSync(this.dir, { recursive: true });
+      fs10.mkdirSync(this.dir, { recursive: true });
       const tmp = `${this.file}.tmp`;
-      fs7.writeFileSync(tmp, JSON.stringify(body));
-      fs7.renameSync(tmp, this.file);
+      fs10.writeFileSync(tmp, JSON.stringify(body));
+      fs10.renameSync(tmp, this.file);
     } catch {
     }
   }
@@ -950,24 +953,24 @@ var LiveStatsBus = class {
   siblings(now = Date.now()) {
     let entries;
     try {
-      entries = fs7.readdirSync(this.dir);
+      entries = fs10.readdirSync(this.dir);
     } catch {
       return [];
     }
     const out2 = [];
     for (const name of entries.sort()) {
       if (!/^serve-\d+\.json$/.test(name)) continue;
-      const file = path37.join(this.dir, name);
+      const file = path39.join(this.dir, name);
       let parsed;
       try {
-        parsed = JSON.parse(fs7.readFileSync(file, "utf8"));
+        parsed = JSON.parse(fs10.readFileSync(file, "utf8"));
       } catch {
         continue;
       }
       if (typeof parsed?.pid !== "number" || typeof parsed.updatedAt !== "number" || !parsed.snapshot?.totals) continue;
       if (now - parsed.updatedAt > STALE_MS) {
         try {
-          fs7.unlinkSync(file);
+          fs10.unlinkSync(file);
         } catch {
         }
         continue;
@@ -979,7 +982,7 @@ var LiveStatsBus = class {
   }
   unlinkOwn = () => {
     try {
-      fs7.unlinkSync(this.file);
+      fs10.unlinkSync(this.file);
     } catch {
     }
   };
@@ -1292,12 +1295,12 @@ var LedgerTail = class {
     if (size === this.offset) return;
     let chunk;
     try {
-      const fd = fs7.openSync(this.file, "r");
+      const fd = fs10.openSync(this.file, "r");
       try {
         chunk = Buffer.alloc(size - this.offset);
-        fs7.readSync(fd, chunk, 0, chunk.length, this.offset);
+        fs10.readSync(fd, chunk, 0, chunk.length, this.offset);
       } finally {
-        fs7.closeSync(fd);
+        fs10.closeSync(fd);
       }
     } catch {
       return;
@@ -1310,7 +1313,7 @@ var LedgerTail = class {
   }
   sizeOf() {
     try {
-      return fs7.statSync(this.file).size;
+      return fs10.statSync(this.file).size;
     } catch {
       return 0;
     }
@@ -1342,7 +1345,7 @@ function ingestLedgerLine(stats, line, now) {
 // src/commands/serve.ts
 var SHARE_FLUSH_INTERVAL_MS = 5 * 60 * 1e3;
 function registerServe(program) {
-  const cmd = program.command("serve").description("start Vibgrate AI Context \u2014 local-first MCP serving your code map, drift & version-correct docs to your AI").option("--http", "serve over streamable HTTP instead of stdio").option("--port <n>", "port for --http", "7437").option("--host <h>", "host for --http", "127.0.0.1").option("--savings", "record local, counts-only usage savings (opt-in; off by default)").option("--share-stats", "ALSO upload the counts-only usage ledger to Vibgrate to improve the local MCP (opt-in; off by default; implies --savings; disabled under --local)").option("--dedup", "collapse a node's heavy relation lists on repeat reads within a session (opt-in; saves tokens)").option("--no-refresh", "serve the map as built \u2014 skip the auto-rebuild when files change").action(async function(opts) {
+  const cmd = program.command("serve").description("start Vibgrate AI Context \u2014 local-first MCP serving your code map, drift & version-correct docs to your AI").option("--http", "serve over streamable HTTP instead of stdio").option("--port <n>", "port for --http", "7437").option("--host <h>", "host for --http", "127.0.0.1").option("--savings", "record local, counts-only usage savings (opt-in; off by default)").option("--share-stats", "ALSO upload the counts-only usage ledger to Vibgrate to improve the local MCP (opt-in; off by default; implies --savings; disabled under --local)").option("--dedup", "collapse a node's heavy relation lists on repeat reads within a session (opt-in; saves tokens)").option("--no-refresh", "serve the map as built \u2014 skip the auto-rebuild when files change").option("--no-watch", "disable the event-driven file watcher \u2014 freshness falls back to the periodic poll").option("--surface <mode>", 'tool listing surface: "hot" lists only the navigation core (orient/search_symbols/query_graph/get_node); "full" lists all tools. Every tool stays callable either way. Env: VG_MCP_SURFACE').option("--tools <names>", "comma-separated tool names to list (listing only \u2014 all tools remain callable). Env: VG_MCP_TOOLS").action(async function(opts) {
     const global = readGlobal(this);
     const root2 = rootOf(global);
     const graphPath = resolveGraphPath(root2, global.graph);
@@ -1365,8 +1368,15 @@ function registerServe(program) {
       local,
       dedup: opts.dedup === true,
       refresh,
+      watch: opts.watch !== false,
       root: root2,
-      stats
+      stats,
+      // Listing surface: flags win over env; unknown values fall back to the
+      // full surface inside listedToolNames (fail-open).
+      toolSurface: {
+        surface: (opts.surface ?? process.env.VG_MCP_SURFACE) === "hot" ? "hot" : "full",
+        tools: (opts.tools ?? process.env.VG_MCP_TOOLS)?.split(",").map((s) => s.trim()).filter(Boolean)
+      }
     };
     await ensureServableGraph(root2, graphPath, global, refresh);
     if (opts.shareStats === true && local) {
@@ -1455,6 +1465,7 @@ async function serveHttp(graphPath, host, port, opts, freshness, onReady) {
   const { createServer: createHttp } = await import('http');
   const { StreamableHTTPServerTransport } = await import('@modelcontextprotocol/sdk/server/streamableHttp.js');
   const source = new GraphSource(graphPath, opts.refresh !== false, { root: opts.root });
+  if (opts.refresh !== false && opts.watch !== false) source.startWatching();
   const httpServer = createHttp(async (req, res) => {
     if (req.url !== "/mcp") {
       res.writeHead(404).end("not found");
@@ -1695,19 +1706,19 @@ function endOfLine(text, line) {
 }
 var CACHE_VERSION = "vg-lsp-scan-cache/2";
 function cachePath(root2) {
-  return path37.join(cacheDir(root2), "lsp-scan.json");
+  return path39.join(cacheDir(root2), "lsp-scan.json");
 }
 function manifestHash(root2) {
   const files = [];
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = fs7.readdirSync(dir, { withFileTypes: true });
+      entries = fs10.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const abs = path37.join(dir, entry.name);
+      const abs = path39.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (isSkippedDirName(entry.name)) continue;
         walk2(abs);
@@ -1717,8 +1728,8 @@ function manifestHash(root2) {
       const base = entry.name.toLowerCase();
       if (!isManifest(abs) && !SKIP_FILES.has(base)) continue;
       try {
-        const rel = path37.relative(root2, abs).split(path37.sep).join("/");
-        files.push({ rel, hash: hashBytes(fs7.readFileSync(abs)) });
+        const rel = path39.relative(root2, abs).split(path39.sep).join("/");
+        files.push({ rel, hash: hashBytes(fs10.readFileSync(abs)) });
       } catch {
       }
     }
@@ -1728,16 +1739,16 @@ function manifestHash(root2) {
   return hashString(canonicalize(files));
 }
 function isDependencyFile(root2, filePath) {
-  const rel = path37.relative(path37.resolve(root2), path37.resolve(filePath));
-  if (rel === "" || rel.startsWith("..") || path37.isAbsolute(rel)) return false;
-  const parts = rel.split(path37.sep);
+  const rel = path39.relative(path39.resolve(root2), path39.resolve(filePath));
+  if (rel === "" || rel.startsWith("..") || path39.isAbsolute(rel)) return false;
+  const parts = rel.split(path39.sep);
   if (parts.slice(0, -1).some((dir) => isSkippedDirName(dir))) return false;
   const base = parts[parts.length - 1].toLowerCase();
   return isManifest(filePath) || SKIP_FILES.has(base);
 }
 function loadScanCache(root2, key2) {
   try {
-    const raw = JSON.parse(fs7.readFileSync(cachePath(root2), "utf8"));
+    const raw = JSON.parse(fs10.readFileSync(cachePath(root2), "utf8"));
     if (raw.version === CACHE_VERSION && raw.manifestHash === key2.manifestHash && raw.toolVersion === key2.toolVersion && raw.offline === key2.offline && raw.artifact) {
       return { manifestHash: raw.manifestHash, artifact: raw.artifact };
     }
@@ -1747,8 +1758,8 @@ function loadScanCache(root2, key2) {
 }
 function writeScanCache(root2, key2, artifact) {
   try {
-    fs7.mkdirSync(cacheDir(root2), { recursive: true });
-    fs7.writeFileSync(
+    fs10.mkdirSync(cacheDir(root2), { recursive: true });
+    fs10.writeFileSync(
       cachePath(root2),
       stableStringify(
         { version: CACHE_VERSION, manifestHash: key2.manifestHash, toolVersion: key2.toolVersion, offline: key2.offline, artifact },
@@ -1761,7 +1772,7 @@ function writeScanCache(root2, key2, artifact) {
 var MAX_ENTRIES = 1e3;
 var KEEP_ENTRIES = 500;
 function historyPath(root2) {
-  return path37.join(root2, ".vibgrate", "score-history.jsonl");
+  return path39.join(root2, ".vibgrate", "score-history.jsonl");
 }
 function parseLine(line) {
   try {
@@ -1775,7 +1786,7 @@ function parseLine(line) {
 }
 function readHistory(root2) {
   try {
-    return fs7.readFileSync(historyPath(root2), "utf8").split("\n").filter((l) => l.trim()).map(parseLine).filter((e) => e !== null);
+    return fs10.readFileSync(historyPath(root2), "utf8").split("\n").filter((l) => l.trim()).map(parseLine).filter((e) => e !== null);
   } catch {
     return [];
   }
@@ -1802,14 +1813,14 @@ function recordScore(root2, entry) {
       }
     }
     const file = historyPath(root2);
-    fs7.mkdirSync(path37.dirname(file), { recursive: true });
+    fs10.mkdirSync(path39.dirname(file), { recursive: true });
     ensureVibgrateGitignore(root2);
-    fs7.appendFileSync(file, `${JSON.stringify(entry)}
+    fs10.appendFileSync(file, `${JSON.stringify(entry)}
 `);
     const all = readHistory(root2);
     if (all.length > MAX_ENTRIES) {
       const kept = all.slice(-KEEP_ENTRIES);
-      fs7.writeFileSync(file, kept.map((e) => JSON.stringify(e)).join("\n") + "\n");
+      fs10.writeFileSync(file, kept.map((e) => JSON.stringify(e)).join("\n") + "\n");
     }
   } catch {
   }
@@ -1821,6 +1832,10 @@ function deltaFrom(prev, current) {
 }
 
 // src/lsp/graph-query.ts
+function semanticBudgetMs() {
+  const n = Number(process.env.VG_SEMANTIC_BUDGET_MS);
+  return Number.isFinite(n) && n > 0 ? n : 2e4;
+}
 async function runGraphQuery(graph, params, ctx) {
   switch (params.mode) {
     case "ask":
@@ -1846,25 +1861,52 @@ async function runAsk(graph, params, ctx) {
   if (!question) return { ok: false, mode: "ask", error: "bad-request", message: "question is required" };
   const budget = params.budget ?? 2e3;
   const wantSemantic = !!params.semantic && !ctx.offline && ctx.semantic !== false;
-  let result;
+  const log = ctx.log ?? (() => {
+  });
+  let result = null;
   let mode = "lexical";
   let note;
   if (wantSemantic) {
+    const budgetMs = semanticBudgetMs();
+    log(`ask: trying the semantic path (budget ${Math.round(budgetMs / 1e3)}s)`);
     let reason;
-    const embedder = await loadEmbedder({ onUnavailable: (r) => reason = r });
-    if (embedder) {
-      const vectors = await getNodeEmbeddings(graph, embedder, ctx.root);
-      result = await queryGraphSemantic(graph, question, { budget, embedder, nodeVectors: vectors });
-      mode = `semantic (${embedder.id})`;
-    } else {
-      result = queryGraph(graph, question, { budget });
-      note = reason ? unavailableMessage(reason) : "semantic unavailable; used lexical";
+    const started = Date.now();
+    try {
+      result = await withTimeout(
+        (async () => {
+          const embedder = await loadEmbedder({ onUnavailable: (r2) => reason = r2 });
+          if (!embedder) return null;
+          log(`ask: embedder "${embedder.id}" loaded in ${Date.now() - started}ms; embedding nodes\u2026`);
+          const vectors = await getNodeEmbeddings(graph, embedder, ctx.root);
+          log(`ask: ${vectors.size} node vectors ready in ${Date.now() - started}ms; ranking\u2026`);
+          const r = await queryGraphSemantic(graph, question, { budget, embedder, nodeVectors: vectors });
+          mode = `semantic (${embedder.id})`;
+          return r;
+        })(),
+        budgetMs,
+        "semantic search went over its time budget"
+      );
+      if (!result) {
+        note = reason ? unavailableMessage(reason) : "semantic unavailable; used lexical";
+        log(`ask: semantic unavailable (${reason ?? "no backend"}) \u2014 falling back to lexical`);
+      }
+    } catch (err) {
+      mode = "lexical";
+      result = null;
+      note = "semantic search did not finish in time \u2014 answered with fast lexical search. It keeps warming in the background, so the next Ask should be semantic.";
+      log(
+        `ask: semantic path abandoned after ${Date.now() - started}ms (${err instanceof Error ? err.message : String(err)}) \u2014 falling back to lexical`
+      );
     }
-  } else {
+  } else if (params.semantic && ctx.semantic === false) {
+    note = "semantic search is turned off \u2014 used lexical";
+  } else if (params.semantic && ctx.offline) {
+    note = "semantic skipped \u2014 Vibgrate is running offline";
+  }
+  if (!result) {
     result = queryGraph(graph, question, { budget });
-    if (params.semantic && ctx.semantic === false) note = "semantic search is turned off \u2014 used lexical";
-    else if (params.semantic && ctx.offline) note = "semantic skipped \u2014 Vibgrate is running offline";
   }
+  log(`ask: answered with ${mode} \u2014 ${result.matches.length} match(es)`);
   return {
     ok: true,
     mode: "ask",
@@ -2629,14 +2671,26 @@ var VibgrateLanguageServer = class {
   }
   async onGraphQuery(params) {
     const p = params;
+    const trace = (message) => this.conn.notify("window/logMessage", { type: 3, message: `Vibgrate graph: ${message}` });
     if (!this.opts.graph) {
+      trace(`${p.mode} refused \u2014 the local Vibgrate Graph is turned off (--no-graph)`);
       return { ok: false, mode: p.mode, error: "disabled", message: "the local Vibgrate Graph is turned off" };
     }
+    const started = Date.now();
     const graph = await this.graphForQuery();
     if (!graph) {
+      trace(`${p.mode} has no code map yet \u2014 it is still building`);
       return { ok: false, mode: p.mode, error: "not-found", message: "no code map yet \u2014 it is still building" };
     }
-    return runGraphQuery(graph, p, { root: this.opts.root, offline: this.opts.offline, semantic: this.opts.semantic });
+    trace(
+      `${p.mode} over ${graph.nodes.length} nodes / ${graph.edges.length} edges (map ready in ${Date.now() - started}ms)`
+    );
+    return runGraphQuery(graph, p, {
+      root: this.opts.root,
+      offline: this.opts.offline,
+      semantic: this.opts.semantic,
+      log: trace
+    });
   }
   /**
    * `vibgrate/enrich` — lazy vulnerability enrichment for one expanded package,
@@ -2682,10 +2736,10 @@ var VibgrateLanguageServer = class {
       const ecosystem = osvEcosystem(proj.type);
       if (!ecosystem) continue;
       const relManifest = manifestRelativePath(proj);
-      const absManifest = path37.resolve(this.opts.root, relManifest);
+      const absManifest = path39.resolve(this.opts.root, relManifest);
       let text = null;
       try {
-        if (fs7.existsSync(absManifest)) text = fs7.readFileSync(absManifest, "utf8");
+        if (fs10.existsSync(absManifest)) text = fs10.readFileSync(absManifest, "utf8");
       } catch {
         text = null;
       }
@@ -2815,9 +2869,9 @@ function pruneArtifactProjects(a) {
   return { ...a, projects, findings };
 }
 function projectByPath(a, projectPath) {
-  const want = path37.normalize(projectPath === "" ? "." : projectPath);
+  const want = path39.normalize(projectPath === "" ? "." : projectPath);
   for (const proj of a.projects ?? []) {
-    const got = path37.normalize(proj.path === "" ? "." : proj.path);
+    const got = path39.normalize(proj.path === "" ? "." : proj.path);
     if (got === want) return proj;
   }
   return void 0;
@@ -2854,12 +2908,12 @@ function buildProjectRefs(rootDir, projects) {
   return refs.length > 0 ? refs : void 0;
 }
 function projectForFile(root2, a, filePath) {
-  const dir = path37.dirname(path37.resolve(filePath));
+  const dir = path39.dirname(path39.resolve(filePath));
   let best;
   let bestLen = -1;
   for (const proj of a.projects ?? []) {
-    const projDir = path37.resolve(root2, proj.path);
-    if ((dir === projDir || dir.startsWith(projDir + path37.sep)) && projDir.length > bestLen) {
+    const projDir = path39.resolve(root2, proj.path);
+    if ((dir === projDir || dir.startsWith(projDir + path39.sep)) && projDir.length > bestLen) {
       best = proj;
       bestLen = projDir.length;
     }
@@ -2867,7 +2921,7 @@ function projectForFile(root2, a, filePath) {
   return best;
 }
 function sameProject(location, projectPath) {
-  return path37.normalize(location) === path37.normalize(projectPath);
+  return path39.normalize(location) === path39.normalize(projectPath);
 }
 function hasReleaseDates(a) {
   for (const proj of a.projects ?? []) {
@@ -2937,10 +2991,10 @@ function buildBreakdown(rootDir, projects) {
     const relManifest = manifestRelativePath(p);
     if (isPrunedWorkspacePath(p.path) || isPrunedWorkspacePath(relManifest)) continue;
     const ecosystem = osvEcosystem(p.type);
-    const absManifest = path37.resolve(rootDir, relManifest);
+    const absManifest = path39.resolve(rootDir, relManifest);
     let text = null;
     try {
-      if (fs7.existsSync(absManifest)) text = fs7.readFileSync(absManifest, "utf8");
+      if (fs10.existsSync(absManifest)) text = fs10.readFileSync(absManifest, "utf8");
     } catch {
       text = null;
     }
@@ -3005,34 +3059,34 @@ function buildBreakdown(rootDir, projects) {
 }
 function manifestRelativePath(proj) {
   const base = proj.path === "." || proj.path === "" ? "" : proj.path;
-  const join27 = (name) => base ? path37.join(base, name) : name;
+  const join29 = (name) => base ? path39.join(base, name) : name;
   switch (proj.type) {
     case "node":
     case "typescript":
-      return join27("package.json");
+      return join29("package.json");
     case "python":
-      return join27("pyproject.toml");
+      return join29("pyproject.toml");
     case "go":
-      return join27("go.mod");
+      return join29("go.mod");
     case "rust":
-      return join27("Cargo.toml");
+      return join29("Cargo.toml");
     case "ruby":
-      return join27("Gemfile");
+      return join29("Gemfile");
     case "php":
-      return join27("composer.json");
+      return join29("composer.json");
     case "java":
     case "kotlin":
     case "scala":
     case "groovy":
-      return join27("pom.xml");
+      return join29("pom.xml");
     case "dotnet":
-      return join27(proj.name ? `${proj.name}.csproj` : "Directory.Build.props");
+      return join29(proj.name ? `${proj.name}.csproj` : "Directory.Build.props");
     case "dart":
-      return join27("pubspec.yaml");
+      return join29("pubspec.yaml");
     case "elixir":
-      return join27("mix.exs");
+      return join29("mix.exs");
     default:
-      return join27("package.json");
+      return join29("package.json");
   }
 }
 function lockfileRelativePath(rootDir, proj) {
@@ -3063,9 +3117,9 @@ function lockfileRelativePath(rootDir, proj) {
   const dirsToTry = base ? [base, ""] : [""];
   for (const dir of dirsToTry) {
     for (const name of candidateNames) {
-      const rel = dir ? path37.join(dir, name) : name;
+      const rel = dir ? path39.join(dir, name) : name;
       try {
-        if (fs7.existsSync(path37.join(rootDir, rel))) return rel;
+        if (fs10.existsSync(path39.join(rootDir, rel))) return rel;
       } catch {
       }
     }
@@ -3136,10 +3190,10 @@ function lookupImportFiles(map, pkg) {
 }
 function firstPackageMentionLine(root2, relFile, pkg) {
   try {
-    const abs = path37.resolve(root2, relFile);
-    const stat2 = fs7.statSync(abs);
+    const abs = path39.resolve(root2, relFile);
+    const stat2 = fs10.statSync(abs);
     if (!stat2.isFile() || stat2.size > 256 * 1024) return null;
-    const text = fs7.readFileSync(abs, "utf8");
+    const text = fs10.readFileSync(abs, "utf8");
     const tokens = [pkg];
     if (pkg.startsWith("@")) {
       const parts = pkg.split("/");
@@ -3291,7 +3345,7 @@ function hoverMarkdown(dep, contribution) {
   return lines.join("\n");
 }
 function startLanguageServer(opts) {
-  if (!fs7.existsSync(opts.root)) {
+  if (!fs10.existsSync(opts.root)) {
     process.stderr.write(`vg lsp: root does not exist: ${opts.root}
 `);
     process.exit(1);
@@ -3333,10 +3387,90 @@ function registerLsp(program) {
   });
   applyGlobalOptions(cmd);
 }
+var HOOK_NEEDLE = "vg hook pre-tool-use";
+var MATCHER = "Grep|Glob";
+var HOOK_TIMEOUT_S = 10;
+function hookCommand(vgBin) {
+  return `${vgBin} hook pre-tool-use`;
+}
+function installClaudeHooks(root2, vgBin = "vg") {
+  const file = path39.join(root2, ".claude", "settings.json");
+  const rel = path39.join(".claude", "settings.json");
+  let settings = {};
+  if (fs10.existsSync(file)) {
+    try {
+      const parsed = JSON.parse(fs10.readFileSync(file, "utf8"));
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return { file: rel, status: "skipped", note: "settings.json is not a JSON object \u2014 left untouched" };
+      }
+      settings = parsed;
+    } catch {
+      return { file: rel, status: "skipped", note: "settings.json is not parseable JSON \u2014 left untouched (fix it and rerun)" };
+    }
+  }
+  const hooks = settings.hooks ??= {};
+  if (typeof hooks !== "object" || Array.isArray(hooks)) {
+    return { file: rel, status: "skipped", note: '"hooks" is not an object \u2014 left untouched' };
+  }
+  const pre = hooks.PreToolUse ??= [];
+  if (!Array.isArray(pre)) {
+    return { file: rel, status: "skipped", note: '"hooks.PreToolUse" is not an array \u2014 left untouched' };
+  }
+  const desired = { type: "command", command: hookCommand(vgBin), timeout: HOOK_TIMEOUT_S };
+  for (const group of pre) {
+    for (const entry of group.hooks ?? []) {
+      if (typeof entry.command === "string" && entry.command.includes(HOOK_NEEDLE)) {
+        if (entry.command === desired.command && entry.timeout === desired.timeout && group.matcher === MATCHER) {
+          return { file: rel, status: "unchanged" };
+        }
+        entry.command = desired.command;
+        entry.timeout = desired.timeout;
+        group.matcher = MATCHER;
+        writeSettings(file, settings);
+        return { file: rel, status: "written", note: "updated existing vg hook entry" };
+      }
+    }
+  }
+  pre.push({ matcher: MATCHER, hooks: [desired] });
+  writeSettings(file, settings);
+  return { file: rel, status: "written" };
+}
+function uninstallClaudeHooks(root2) {
+  const file = path39.join(root2, ".claude", "settings.json");
+  const rel = path39.join(".claude", "settings.json");
+  if (!fs10.existsSync(file)) return { file: rel, status: "unchanged" };
+  let settings;
+  try {
+    settings = JSON.parse(fs10.readFileSync(file, "utf8"));
+  } catch {
+    return { file: rel, status: "skipped", note: "settings.json is not parseable JSON \u2014 left untouched" };
+  }
+  const hooks = settings.hooks;
+  const pre = hooks?.PreToolUse;
+  if (!Array.isArray(pre)) return { file: rel, status: "unchanged" };
+  let removed = false;
+  for (const group of pre) {
+    const before = group.hooks?.length ?? 0;
+    group.hooks = (group.hooks ?? []).filter((e) => !(typeof e.command === "string" && e.command.includes(HOOK_NEEDLE)));
+    if (group.hooks.length !== before) removed = true;
+  }
+  const kept = pre.filter((g) => (g.hooks?.length ?? 0) > 0);
+  if (!removed) return { file: rel, status: "unchanged" };
+  if (kept.length) hooks.PreToolUse = kept;
+  else delete hooks.PreToolUse;
+  if (hooks && Object.keys(hooks).length === 0) delete settings.hooks;
+  writeSettings(file, settings);
+  return { file: rel, status: "written" };
+}
+function writeSettings(file, settings) {
+  fs10.mkdirSync(path39.dirname(file), { recursive: true });
+  fs10.writeFileSync(file, `${JSON.stringify(settings, null, 2)}
+`);
+}
 
 // src/commands/install.ts
 function registerInstall(program) {
-  const install = program.command("install").description("add vg to your AI assistant(s): skill + MCP + advisory nudge").argument("[tools...]", `assistant ids: ${ASSISTANTS.map((a) => a.id).join(", ")}`).option("--all", "install for every supported assistant").option("--detect", "detect assistants in use (repo footprint, home config, PATH) and install for those; with --list, only report what was detected").option("--list", "show the support matrix and exit").option("--no-hook", "skip the advisory nudge").action(function(tools, opts) {
+  const install = program.command("install").description("add vg to your AI assistant(s): skill + MCP + advisory nudge").argument("[tools...]", `assistant ids: ${ASSISTANTS.map((a) => a.id).join(", ")}`).option("--all", "install for every supported assistant").option("--detect", "detect assistants in use (repo footprint, home config, PATH) and install for those; with --list, only report what was detected").option("--list", "show the support matrix and exit").option("--no-hook", "skip the advisory nudge").option("--hooks", "also wire the PreToolUse enrichment hook (Claude Code): Grep/Glob calls get graph context via `vg hook pre-tool-use` (project .claude/settings.json; opt-in)").action(function(tools, opts) {
     const global = readGlobal(this);
     const root2 = rootOf(global);
     const detected = opts.detect ? detectAssistants(root2) : [];
@@ -3400,6 +3534,12 @@ function registerInstall(program) {
     for (const r of results) {
       info(`${c.green("\u2714")} ${c.bold(r.id)} \u2014 wrote ${r.wrote.join(", ")}${r.skipped.length ? c.dim(` (skipped ${r.skipped.join(", ")})`) : ""}`);
     }
+    if (opts.hooks && targets.some((a) => a.id === "claude")) {
+      const vgBin = launch.command === "npx" ? null : launch.command;
+      const hooksResult = vgBin ? installClaudeHooks(root2, vgBin) : { file: ".claude/settings.json", status: "skipped", note: "vg is not installed on PATH \u2014 hooks need a fast binary (npm i -g @vibgrate/cli), rerun with --hooks after" };
+      if (hooksResult.status === "written") info(`${c.green("\u2714")} ${c.bold("hooks")} \u2014 wrote PreToolUse enrichment into ${hooksResult.file}`);
+      else if (hooksResult.note) info(`${c.yellow("!")} hooks \u2014 ${hooksResult.note}`);
+    }
     if (launch.note && results.some((r) => r.note)) info(`${c.yellow("!")} ${launch.note}`);
     if (smallRepo) info(c.dim(`  note: small repo (${fileCount} files) \u2014 nudge says searching is fine; vg is still used for impact/tests`));
     info(c.dim(`  wrote ${navConfig} \u2014 deferred-loading config for Claude-API agents (lower per-step token cost)`));
@@ -3410,6 +3550,10 @@ function registerInstall(program) {
     const global = readGlobal(this);
     const root2 = rootOf(global);
     const results = tools.map(resolve5).map((a) => ({ id: a.id, removed: uninstallAssistant(a, root2, !!opts.purge) }));
+    if (tools.map(resolve5).some((a) => a.id === "claude")) {
+      const hooksResult = uninstallClaudeHooks(root2);
+      if (hooksResult.status === "written") results.find((r) => r.id === "claude")?.removed.push(`${hooksResult.file} (vg hook entries)`);
+    }
     if (global.json) {
       json({ root: root2, results });
       return;
@@ -3434,14 +3578,289 @@ function resolve5(id) {
   }
   return a;
 }
+var RELEVANCE_MODULE_NAME = "@vibgrate/relevance";
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+function registryBase(opts) {
+  return (process.env.VIBGRATE_MODULE_REGISTRY || opts.registry || DEFAULT_REGISTRY).replace(/\/+$/, "");
+}
+function stateFile() {
+  return path39.join(path39.dirname(relevanceModuleDir()), "consent.json");
+}
+function readConsent() {
+  try {
+    return JSON.parse(fs10.readFileSync(stateFile(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeConsent(state) {
+  try {
+    fs10.mkdirSync(path39.dirname(stateFile()), { recursive: true });
+    fs10.writeFileSync(stateFile(), JSON.stringify(state));
+  } catch {
+  }
+}
+function kernelDisabled() {
+  const v = process.env.VIBGRATE_NO_KERNEL;
+  return v === "1" || v === "true";
+}
+function moduleInstalled() {
+  try {
+    const meta = JSON.parse(fs10.readFileSync(path39.join(relevanceModuleDir(), ".module.json"), "utf8"));
+    if (fs10.existsSync(path39.join(relevanceModuleDir(), "index.js"))) {
+      return { installed: true, version: meta.version };
+    }
+  } catch {
+  }
+  return { installed: false };
+}
+var DISCLOSURE = "vg can install the optional Vibgrate relevance module (proprietary license, runs fully locally, improves how questions find the code they mean). Disable any time with VIBGRATE_NO_KERNEL=1.";
+function verifyIntegrity(buf, integrity, shasum) {
+  if (integrity) {
+    const [algo, expected] = integrity.split("-", 2);
+    if (!algo || !expected) throw new Error("malformed integrity metadata");
+    const actual = createHash(algo).update(buf).digest("base64");
+    if (actual !== expected) throw new Error(`integrity mismatch (${algo})`);
+    return;
+  }
+  if (shasum) {
+    const actual = createHash("sha1").update(buf).digest("hex");
+    if (actual !== shasum) throw new Error("integrity mismatch (shasum)");
+    return;
+  }
+  throw new Error("registry provided no integrity metadata");
+}
+function untar(data) {
+  const out2 = [];
+  let offset = 0;
+  let pendingName = null;
+  while (offset + 512 <= data.length) {
+    const block = data.subarray(offset, offset + 512);
+    offset += 512;
+    if (block.every((b) => b === 0)) continue;
+    const rawName = block.subarray(0, 100).toString("utf8").replace(/\0.*$/, "");
+    const size = parseInt(block.subarray(124, 136).toString("utf8").replace(/\0.*$/, "").trim() || "0", 8);
+    const type = String.fromCharCode(block[156]);
+    const prefix = block.subarray(345, 500).toString("utf8").replace(/\0.*$/, "");
+    const body = data.subarray(offset, offset + size);
+    offset += Math.ceil(size / 512) * 512;
+    if (type === "L") {
+      pendingName = body.toString("utf8").replace(/\0.*$/, "");
+      continue;
+    }
+    if (type === "x" || type === "g") {
+      const m = /(?:^|\n)\d+ path=([^\n]+)\n/.exec(body.toString("utf8"));
+      if (m) pendingName = m[1];
+      continue;
+    }
+    if (type !== "0" && type !== "\0") continue;
+    const name = pendingName ?? (prefix ? `${prefix}/${rawName}` : rawName);
+    pendingName = null;
+    if (name.split("/").includes("..") || path39.isAbsolute(name)) {
+      throw new Error(`unsafe path in tarball: ${name}`);
+    }
+    out2.push({ name, body: Buffer.from(body) });
+  }
+  return out2;
+}
+async function installRelevanceModule(opts = {}) {
+  if (kernelDisabled()) return { status: "disabled", detail: "VIBGRATE_NO_KERNEL is set" };
+  const existing = moduleInstalled();
+  if (existing.installed && !opts.force) return { status: "already-installed", version: existing.version };
+  const doFetch = opts.fetchImpl ?? fetch;
+  const base = registryBase(opts);
+  try {
+    const metaRes = await doFetch(`${base}/${RELEVANCE_MODULE_NAME.replace("/", "%2f")}`);
+    if (!metaRes.ok) return { status: "unavailable", detail: `registry ${metaRes.status}` };
+    const meta = await metaRes.json();
+    const version = meta["dist-tags"]?.latest;
+    const dist = version ? meta.versions?.[version]?.dist : void 0;
+    if (!version || !dist?.tarball) return { status: "unavailable", detail: "no published version" };
+    const tarRes = await doFetch(dist.tarball);
+    if (!tarRes.ok) return { status: "unavailable", detail: `tarball ${tarRes.status}` };
+    const gz = Buffer.from(await tarRes.arrayBuffer());
+    verifyIntegrity(gz, dist.integrity, dist.shasum);
+    const entries = untar(zlib.gunzipSync(gz));
+    const dir = relevanceModuleDir();
+    fs10.rmSync(dir, { recursive: true, force: true });
+    fs10.mkdirSync(dir, { recursive: true });
+    let wrote = 0;
+    for (const e of entries) {
+      let rel = null;
+      if (e.name.startsWith("package/dist/")) rel = e.name.slice("package/dist/".length);
+      else if (e.name === "package/LICENSE" || e.name === "package/README.md") rel = e.name.slice("package/".length);
+      if (!rel) continue;
+      const target = path39.join(dir, rel);
+      if (!target.startsWith(dir + path39.sep) && target !== dir) throw new Error(`unsafe extract path: ${rel}`);
+      fs10.mkdirSync(path39.dirname(target), { recursive: true });
+      fs10.writeFileSync(target, e.body);
+      wrote += 1;
+    }
+    if (!wrote || !fs10.existsSync(path39.join(dir, "index.js"))) {
+      fs10.rmSync(dir, { recursive: true, force: true });
+      return { status: "unavailable", detail: "package layout not recognized (no dist/index.js)" };
+    }
+    fs10.writeFileSync(path39.join(dir, ".module.json"), JSON.stringify({ name: RELEVANCE_MODULE_NAME, version }));
+    resetRelevanceProviderCache();
+    return { status: "installed", version };
+  } catch (e) {
+    return { status: "unavailable", detail: String(e.message ?? e).slice(0, 200) };
+  }
+}
+function removeRelevanceModule() {
+  fs10.rmSync(relevanceModuleDir(), { recursive: true, force: true });
+  resetRelevanceProviderCache();
+}
+async function ensureRelevanceModule(io = {}) {
+  try {
+    if (kernelDisabled()) return { status: "disabled" };
+    const existing = moduleInstalled();
+    if (existing.installed) return { status: "already-installed", version: existing.version };
+    if (readConsent().relevance === "denied") return { status: "declined" };
+    return await installRelevanceModule({ fetchImpl: io.fetchImpl });
+  } catch {
+    return { status: "unavailable", detail: "auto-install failed" };
+  }
+}
+
+// src/commands/module.ts
+function registerModule(program) {
+  const cmd = program.command("module").description("manage optional local modules (relevance)");
+  cmd.command("install").description("install an optional module (fetches from the registry, integrity-checked)").argument("<name>", "module name (supported: relevance)").option("--yes", "skip the confirmation prompt").option("--force", "reinstall even when already present").action(async function(name, opts) {
+    const global = readGlobal(this);
+    requireRelevance(name);
+    if (kernelDisabled()) {
+      throw new CliError("VIBGRATE_NO_KERNEL is set \u2014 unset it to install the relevance module", ExitCode.USAGE_ERROR);
+    }
+    if (!opts.yes && process.stdin.isTTY && process.stdout.isTTY) {
+      const ok = await confirm(`${DISCLOSURE}
+Install now? [Y/n] `);
+      if (!ok) {
+        writeConsent({ ...readConsent(), relevance: "denied" });
+        info("not installed");
+        return;
+      }
+    }
+    writeConsent({ ...readConsent(), relevance: "granted" });
+    const result = await installRelevanceModule({ force: opts.force });
+    if (global.json) {
+      json(result);
+      if (result.status === "unavailable") process.exitCode = ExitCode.ERROR;
+      return;
+    }
+    if (result.status === "installed") out(`installed ${RELEVANCE_MODULE_NAME}@${result.version}`);
+    else if (result.status === "already-installed") out(`already installed (${result.version ?? "unknown"}) \u2014 use --force to reinstall`);
+    else throw new CliError(`install failed: ${result.detail ?? result.status} \u2014 check network access to the registry, or retry later`, ExitCode.ERROR);
+  });
+  cmd.command("remove").description("remove an installed module").argument("<name>", "module name (supported: relevance)").action(async function(name) {
+    requireRelevance(name);
+    removeRelevanceModule();
+    out("removed");
+  });
+  cmd.command("status").description("show installed modules and whether they load").action(async function() {
+    const global = readGlobal(this);
+    const installed = moduleInstalled();
+    resetRelevanceProviderCache();
+    const provider = installed.installed ? await loadRelevanceProvider() : null;
+    const status = {
+      relevance: {
+        installed: installed.installed,
+        version: installed.version ?? null,
+        loadable: !!provider,
+        providerVersion: provider ? provider.version() : null,
+        disabled: kernelDisabled(),
+        consent: readConsent().relevance ?? "unset"
+      }
+    };
+    if (global.json) {
+      json(status);
+      return;
+    }
+    const r = status.relevance;
+    out(`relevance: ${r.installed ? `installed ${r.version}` : "not installed"}${r.disabled ? " (disabled via VIBGRATE_NO_KERNEL)" : ""}`);
+    if (r.installed) out(`  loads: ${r.loadable ? `yes (${r.providerVersion})` : "no"}`);
+    info(c.dim(`  consent: ${r.consent}`));
+  });
+  applyGlobalOptions(cmd);
+}
+function requireRelevance(name) {
+  if (name !== "relevance") {
+    throw usageError(`unknown module '${name}' \u2014 supported modules: relevance`);
+  }
+}
+function confirm(question) {
+  return new Promise((resolve21) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve21(answer.trim() === "" || /^y(es)?$/i.test(answer.trim()));
+    });
+  });
+}
+var MAX_HOOK_MATCHES = 5;
+var MIN_PATTERN_CHARS = 3;
+function patternToQuery(pattern) {
+  return pattern.replace(/\\[dwsbDWSB]/g, " ").replace(/[\\^$.*+?()[\]{}|]/g, " ").replace(/\s+/g, " ").trim();
+}
+function hookContext(payloadText, root2, graphOverride) {
+  let payload;
+  try {
+    payload = JSON.parse(payloadText);
+  } catch {
+    return null;
+  }
+  if (payload.tool_name !== "Grep" && payload.tool_name !== "Glob") return null;
+  const raw = payload.tool_input?.pattern ?? payload.tool_input?.query ?? "";
+  const query = patternToQuery(String(raw));
+  if (query.length < MIN_PATTERN_CHARS) return null;
+  const graphPath = resolveGraphPath(root2, graphOverride);
+  let graph;
+  try {
+    const preferred = loadGraphPreferIndex(root2, graphPath);
+    graph = preferred ? preferred.graph : parseGraph(fs10.readFileSync(graphPath, "utf8"));
+  } catch {
+    return null;
+  }
+  const result = queryGraph(graph, query, {});
+  const matches = result.matches.slice(0, MAX_HOOK_MATCHES);
+  if (!matches.length) return null;
+  const lines = matches.map(
+    (m) => `- \`${m.node.qualifiedName}\` (${m.node.kind}) \u2014 ${m.node.file}:${m.node.span.start}${m.node.isHub ? " [hub \u2014 check impact_of before changing]" : ""}`
+  );
+  return [
+    `vg code map \u2014 symbols matching "${query}":`,
+    ...lines,
+    "These locations come from the deterministic code graph; prefer them over scanning the raw grep output."
+  ].join("\n");
+}
+function registerHook(program) {
+  const cmd = program.command("hook", { hidden: true }).description("assistant-host hook endpoints (wired by `vg install --hooks`)");
+  const pre = cmd.command("pre-tool-use").description("PreToolUse enrichment: annotate Grep/Glob calls with graph context (stdin: host hook payload)").action(async function() {
+    const global = readGlobal(this);
+    const root2 = rootOf(global);
+    try {
+      const stdin = fs10.readFileSync(0, "utf8");
+      const context = hookContext(stdin, root2, global.graph);
+      if (context) {
+        process.stdout.write(
+          `${JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", additionalContext: context } })}
+`
+        );
+      }
+    } catch {
+    }
+  });
+  applyGlobalOptions(pre);
+  applyGlobalOptions(cmd);
+}
 var HOOK_BEGIN = "# vg:begin";
 var HOOK_END = "# vg:end";
 function registerShare(program) {
   const cmd = program.command("share").description("make the map committable + auto-updating for your team (git)").option("--undo", "reverse what `vg share` installed").option("--reports", "also commit graph.html / GRAPH_REPORT.md (default: gitignored)").action(function(opts) {
     const global = readGlobal(this);
     const root2 = rootOf(global);
-    const gitDir = path37.join(root2, ".git");
-    if (!fs7.existsSync(gitDir)) {
+    const gitDir = path39.join(root2, ".git");
+    if (!fs10.existsSync(gitDir)) {
       throw new CliError("not a git repository \u2014 run `vg share` inside a git repo", ExitCode.USAGE_ERROR);
     }
     if (opts.undo) {
@@ -3462,23 +3881,23 @@ function registerShare(program) {
   applyGlobalOptions(cmd);
 }
 function writeVibgrateGitignore(root2, reports) {
-  const dir = path37.join(root2, ".vibgrate");
-  fs7.mkdirSync(dir, { recursive: true });
+  const dir = path39.join(root2, ".vibgrate");
+  fs10.mkdirSync(dir, { recursive: true });
   const lines = ["# Managed by `vg share` \u2014 keep graph.json committed, ignore the rest", "cache/", "facts.jsonl", "graph.snap"];
   if (!reports) lines.push("graph.html", "GRAPH_REPORT.md");
-  fs7.writeFileSync(path37.join(dir, ".gitignore"), `${lines.join("\n")}
+  fs10.writeFileSync(path39.join(dir, ".gitignore"), `${lines.join("\n")}
 `);
 }
 function writeGitAttributes(root2) {
-  const file = path37.join(root2, ".gitattributes");
+  const file = path39.join(root2, ".gitattributes");
   const line = ".vibgrate/graph.json merge=vg";
-  let content = fs7.existsSync(file) ? fs7.readFileSync(file, "utf8") : "";
+  let content = fs10.existsSync(file) ? fs10.readFileSync(file, "utf8") : "";
   if (!content.split("\n").some((l) => l.trim() === line)) {
     content = content.length ? `${content.replace(/\s*$/, "")}
 ${line}
 ` : `${line}
 `;
-    fs7.writeFileSync(file, content);
+    fs10.writeFileSync(file, content);
   }
 }
 function configureMergeDriver(root2) {
@@ -3487,8 +3906,8 @@ function configureMergeDriver(root2) {
 }
 function installPreCommitHook(root2) {
   const hooksDir = hookDir(root2);
-  fs7.mkdirSync(hooksDir, { recursive: true });
-  const file = path37.join(hooksDir, "pre-commit");
+  fs10.mkdirSync(hooksDir, { recursive: true });
+  const file = path39.join(hooksDir, "pre-commit");
   const block = [
     HOOK_BEGIN,
     "if command -v vg >/dev/null 2>&1; then",
@@ -3497,7 +3916,7 @@ function installPreCommitHook(root2) {
     "fi",
     HOOK_END
   ].join("\n");
-  let content = fs7.existsSync(file) ? fs7.readFileSync(file, "utf8") : "#!/bin/sh\n";
+  let content = fs10.existsSync(file) ? fs10.readFileSync(file, "utf8") : "#!/bin/sh\n";
   const re = new RegExp(`${escapeRe(HOOK_BEGIN)}[\\s\\S]*?${escapeRe(HOOK_END)}`);
   if (re.test(content)) content = content.replace(re, block);
   else content = `${content.replace(/\s*$/, "")}
@@ -3506,21 +3925,21 @@ ${block}
 `;
   if (!content.startsWith("#!")) content = `#!/bin/sh
 ${content}`;
-  fs7.writeFileSync(file, content);
-  fs7.chmodSync(file, 493);
+  fs10.writeFileSync(file, content);
+  fs10.chmodSync(file, 493);
 }
 function undo(root2) {
-  const hookFile = path37.join(hookDir(root2), "pre-commit");
-  if (fs7.existsSync(hookFile)) {
+  const hookFile = path39.join(hookDir(root2), "pre-commit");
+  if (fs10.existsSync(hookFile)) {
     const re = new RegExp(`\\n*${escapeRe(HOOK_BEGIN)}[\\s\\S]*?${escapeRe(HOOK_END)}\\n*`);
-    const next2 = fs7.readFileSync(hookFile, "utf8").replace(re, "\n");
-    if (next2.trim() === "#!/bin/sh") fs7.rmSync(hookFile);
-    else fs7.writeFileSync(hookFile, next2);
+    const next2 = fs10.readFileSync(hookFile, "utf8").replace(re, "\n");
+    if (next2.trim() === "#!/bin/sh") fs10.rmSync(hookFile);
+    else fs10.writeFileSync(hookFile, next2);
   }
-  const attr = path37.join(root2, ".gitattributes");
-  if (fs7.existsSync(attr)) {
-    const next2 = fs7.readFileSync(attr, "utf8").split("\n").filter((l) => l.trim() !== ".vibgrate/graph.json merge=vg").join("\n");
-    fs7.writeFileSync(attr, next2);
+  const attr = path39.join(root2, ".gitattributes");
+  if (fs10.existsSync(attr)) {
+    const next2 = fs10.readFileSync(attr, "utf8").split("\n").filter((l) => l.trim() !== ".vibgrate/graph.json merge=vg").join("\n");
+    fs10.writeFileSync(attr, next2);
   }
   try {
     git(root2, ["config", "--remove-section", "merge.vg"]);
@@ -3530,10 +3949,10 @@ function undo(root2) {
 function hookDir(root2) {
   try {
     const configured = git(root2, ["config", "--get", "core.hooksPath"]).trim();
-    if (configured) return path37.resolve(root2, configured);
+    if (configured) return path39.resolve(root2, configured);
   } catch {
   }
-  return path37.join(root2, ".git", "hooks");
+  return path39.join(root2, ".git", "hooks");
 }
 function git(root2, args) {
   return execFileSync("git", args, { cwd: root2, encoding: "utf8" });
@@ -3542,28 +3961,14 @@ function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 var DEFAULT_DEBOUNCE_MS = 400;
-var SKIP_NAME = /* @__PURE__ */ new Set([
-  ".git",
-  "node_modules",
-  ".vibgrate",
-  "dist",
-  "build",
-  "out",
-  "coverage",
-  ".next",
-  "target",
-  "__pycache__",
-  ".venv",
-  "venv"
-]);
 function registerWatch(program) {
   const cmd = program.command("watch").description("rebuild the code map when files change (debounced)").argument("[paths...]", "folders to watch (default: current folder)").option("--debounce <ms>", "settle time after a change before rebuild", String(DEFAULT_DEBOUNCE_MS)).option("--no-html", "do not write graph.html on each rebuild").option("--no-report", "do not write GRAPH_REPORT.md on each rebuild").option("--fast", "skip precise tsc resolve on rebuilds (heuristic only)").action(async function(paths, opts) {
     const global = readGlobal(this);
     const root2 = rootOf(global);
     const debounceMs = Math.max(50, Number(opts.debounce) || DEFAULT_DEBOUNCE_MS);
-    const watchRoots = (paths.length ? paths : ["."]).map((p) => path37.resolve(root2, p));
+    const watchRoots = (paths.length ? paths : ["."]).map((p) => path39.resolve(root2, p));
     for (const w of watchRoots) {
-      if (!fs7.existsSync(w)) {
+      if (!fs10.existsSync(w)) {
         throw new CliError(`watch path not found: ${w}`, ExitCode.USAGE_ERROR);
       }
     }
@@ -3616,16 +4021,12 @@ function registerWatch(program) {
     const watchers = [];
     for (const w of watchRoots) {
       try {
-        const watcher = fs7.watch(w, { recursive: true }, (_event, filename) => {
+        const watcher = fs10.watch(w, { recursive: true }, (_event, filename) => {
           if (!filename) {
             schedule("change");
             return;
           }
-          const parts = filename.split(path37.sep);
-          if (parts.some((p) => SKIP_NAME.has(p))) return;
-          if (filename.includes(`${path37.sep}.vibgrate${path37.sep}`) || filename.startsWith(".vibgrate")) {
-            return;
-          }
+          if (!isRelevantChange(filename)) return;
           schedule(filename);
         });
         watchers.push(watcher);
@@ -3633,7 +4034,7 @@ function registerWatch(program) {
         throw new CliError(`cannot watch ${w}: ${err.message}`, ExitCode.ERROR);
       }
     }
-    info(c.dim(`vg watch \xB7 watching ${watchRoots.map((p) => path37.relative(root2, p) || ".").join(", ")} (debounce ${debounceMs}ms) \xB7 Ctrl+C to stop`));
+    info(c.dim(`vg watch \xB7 watching ${watchRoots.map((p) => path39.relative(root2, p) || ".").join(", ")} (debounce ${debounceMs}ms) \xB7 Ctrl+C to stop`));
     await new Promise((resolve21) => {
       const stop = () => {
         for (const w of watchers) w.close();
@@ -3966,10 +4367,10 @@ function normalizeStandards(raw) {
 }
 function loadStandards(root2) {
   for (const rel of STANDARDS_FILES) {
-    const p = path37__default.join(root2, rel);
+    const p = path39__default.join(root2, rel);
     let text;
     try {
-      text = fs7__default.readFileSync(p, "utf8");
+      text = fs10__default.readFileSync(p, "utf8");
     } catch {
       continue;
     }
@@ -4687,8 +5088,8 @@ async function runHostBench(options = {}) {
 }
 async function runArmSimulate(input) {
   const { arm, lib, modelPath, turns, trie, env, live } = input;
-  const path39 = `${modelPath}#${arm.id}`;
-  const session = await acquireHostSession(lib, path39);
+  const path41 = `${modelPath}#${arm.id}`;
+  const session = await acquireHostSession(lib, path41);
   const system = "You are a coding agent with a Task Capsule.";
   const capsule = "function readConfig(): Config { return load(); }";
   let last = null;
@@ -5900,7 +6301,7 @@ function registerModels(program) {
         );
       }
     } else {
-      if (!target.path || !fs7.existsSync(target.path)) {
+      if (!target.path || !fs10.existsSync(target.path)) {
         throw new CliError(
           `model file not found at ${target.path || "(unknown path)"} \u2014 it may already be removed.`,
           ExitCode.NOT_FOUND
@@ -5914,7 +6315,7 @@ function registerModels(program) {
       }
       if (!global.json) info(c.dim(`  $ rm ${target.path}`));
       try {
-        fs7.unlinkSync(target.path);
+        fs10.unlinkSync(target.path);
       } catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
         throw new CliError(`could not delete ${target.path}: ${msg}`, ExitCode.ERROR);
@@ -6052,9 +6453,9 @@ function registerModels(program) {
       }
     });
     if (opts.out) {
-      const outPath = path37.resolve(opts.out);
-      fs7.mkdirSync(path37.dirname(outPath), { recursive: true });
-      fs7.writeFileSync(outPath, `${JSON.stringify(report, null, 2)}
+      const outPath = path39.resolve(opts.out);
+      fs10.mkdirSync(path39.dirname(outPath), { recursive: true });
+      fs10.writeFileSync(outPath, `${JSON.stringify(report, null, 2)}
 `);
       if (!global.json) info(c.dim(`  wrote ${outPath}`));
     }
@@ -6203,14 +6604,14 @@ function resolveUninstallTarget(name, runtimeOpt) {
     }
     return exact[0];
   }
-  const base = path37.basename(wantLc);
+  const base = path39.basename(wantLc);
   const soft = fleet.filter((m) => {
     const n = m.name.toLowerCase();
-    return n === base || n.endsWith("/" + base) || n.endsWith(wantLc) || path37.basename(n) === base;
+    return n === base || n.endsWith("/" + base) || n.endsWith(wantLc) || path39.basename(n) === base;
   });
   if (soft.length === 1) return soft[0];
   if (soft.length > 1) {
-    const baseHits = soft.filter((m) => path37.basename(m.name).toLowerCase() === base);
+    const baseHits = soft.filter((m) => path39.basename(m.name).toLowerCase() === base);
     const pool = baseHits.length ? baseHits : soft;
     const order = ["ollama", "gguf", "lm-studio"];
     for (const rt of order) {
@@ -6248,11 +6649,11 @@ function printBackends(backends) {
   }
 }
 function codeConfigPath(root2) {
-  return path37.join(root2, ".vibgrate", "code.json");
+  return path39.join(root2, ".vibgrate", "code.json");
 }
 function loadCodeConfig(root2) {
   try {
-    const raw = JSON.parse(fs7.readFileSync(codeConfigPath(root2), "utf8"));
+    const raw = JSON.parse(fs10.readFileSync(codeConfigPath(root2), "utf8"));
     return sanitize(raw);
   } catch {
     return {};
@@ -6319,7 +6720,7 @@ function contextBudgetFor(config, modelContextWindow) {
 var MCP_CONFIG_FILES = [".cursor/mcp.json", ".vscode/mcp.json", ".mcp.json"];
 function readMcpServersFile(file) {
   try {
-    const raw = JSON.parse(fs7.readFileSync(file, "utf8"));
+    const raw = JSON.parse(fs10.readFileSync(file, "utf8"));
     const map = raw.mcpServers ?? raw.servers;
     return map && typeof map === "object" ? parseMcpServers(map) : {};
   } catch {
@@ -6330,7 +6731,7 @@ function discoverMcpServers(root2, ownServers) {
   const servers = {};
   const sources = [];
   for (const rel of MCP_CONFIG_FILES) {
-    const found = readMcpServersFile(path37.join(root2, rel));
+    const found = readMcpServersFile(path39.join(root2, rel));
     const names = Object.keys(found);
     if (names.length) {
       sources.push(rel);
@@ -6349,6 +6750,9 @@ function registerCode(program) {
   const cmd = program.command("code").description("propose a graph-grounded code edit (guided mode with no instruction; dry-run by default)").argument("[instruction...]", "what to change, in plain language (omit for guided interactive mode)").option("--provider <id>", "backend: vibgrate-relay (Vibgrate Relay), ollama, lmstudio, foundry-local, openrouter, litellm, openai, together, llama-cpp").option("--model <id>", "model id (or set VG_CODE_MODEL). No model is hard-coded \u2014 pick the current best.").option("--mode <mode>", "Code Mode: spark | flow | forge (preferred over raw model names; auto-fits when omitted and no --model)").option("--model-path <gguf>", "gguf path for --provider llama-cpp (weights are never auto-downloaded)").option("-f, --file <path>", "restrict the edit surface to this file (repeatable)", collect, []).option("-b, --budget <n>", "approx context token budget", "3000").option("--apply", "write the change (still requires --yes or an interactive confirm)").option("--yes", "consent to write / to a first-use package install, non-interactively").option("--auto", "autonomous agent: auto-approve every edit and command (use with care)").option("--max-steps <n>", "cap the number of agent steps", "24").option("--single", "one-shot planner (single edit) instead of the multi-step agent").option("--stream", "stream the model output live").option("--stream-json", "machine protocol: NDJSON agent events on stdout, approval decisions on stdin (for host UIs like the VS Code panel)").option("--session", "with --stream-json: stay open for further turns (warm graph and tools) instead of exiting after one").option("--verify [command]", "after the agent finishes, run tests and make it fix failures (uses the config testCommand if no command is given)").option("--continue", "resume the most recent session (recap + restore /undo)").option("--capsule", "use a source-bearing Task Capsule for first context (Fusion A/B; exact source ranges from the graph)").option("--no-capsule", "disable Task Capsule context even if enabled in .vibgrate/code.json").option("--security-tier <tier>", "shell isolation: L0 (host), L1 (Seatbelt/bubblewrap when available), L2/L3 reserved").option("--mock <file>", "use a scripted reply from <file> instead of a model (offline; for tests/CI)").option("-o, --out <file>", "write the JSON result to <file> (implies --json shape; for CI/benchmarks)").action(async function(instructionParts, opts) {
     const global = readGlobal(this);
     const instruction = (instructionParts ?? []).join(" ").trim();
+    if (!global.local) {
+      await ensureRelevanceModule();
+    }
     const config = loadCodeConfig(rootOf(global));
     let provider = opts.provider ?? config.provider;
     let model = opts.model ?? config.model;
@@ -6359,7 +6763,7 @@ function registerCode(program) {
       try {
         const { parseMode: parseMode2, resolveMode: resolveMode2, readOrchestratorState: readOrchestratorState2, activePin: activePin2 } = await import('./model-orchestrator-LHYPJBFH.js');
         const { gatherSystemMemory: gatherSystemMemory2 } = await import('./local-runtime-2ED33KK6.js');
-        const { loadGraph: loadGraph2 } = await import('./load-E3OTM7BS.js');
+        const { loadGraph: loadGraph2 } = await import('./load-T2FOJUPI.js');
         const state = readOrchestratorState2();
         const mode = parseMode2(modeFlag) ?? state.defaultMode ?? void 0;
         const pin = mode ? activePin2(mode, state) : null;
@@ -6439,11 +6843,12 @@ function registerCode(program) {
     const verifyCommand = opts.verify === true ? config.testCommand : typeof opts.verify === "string" ? opts.verify : void 0;
     const verify3 = verifyCommand ? { command: verifyCommand } : void 0;
     const mcp = discoverMcpServers(rootOf(global), config.mcpServers);
-    if (!instruction && !opts.mock) {
+    const stdinFirstTurn = !instruction && !!opts.streamJson && !!opts.session;
+    if (!instruction && !opts.mock && !stdinFirstTurn) {
       if (!(process.stdin.isTTY && process.stdout.isTTY)) {
         throw usageError('say what to change, e.g. `vg code "add a --timeout flag to the scan command"` (guided mode needs an interactive terminal)');
       }
-      const { runInteractive } = await import('./interactive-TMQR6TXM.js');
+      const { runInteractive } = await import('./interactive-6PN237LX.js');
       await runInteractive(
         rootOf(global),
         global,
@@ -6471,9 +6876,9 @@ function registerCode(program) {
       );
       return;
     }
-    if (!instruction) throw usageError('say what to change, e.g. `vg code "add a --timeout flag to the scan command"`');
+    if (!instruction && !stdinFirstTurn) throw usageError('say what to change, e.g. `vg code "add a --timeout flag to the scan command"`');
     {
-      const { ensureCodeMap } = await import('./ensure-map-SMWHKOUY.js');
+      const { ensureCodeMap } = await import('./ensure-map-TAVYMPEG.js');
       const mapRoot = rootOf(global);
       try {
         await ensureCodeMap(mapRoot, global, {
@@ -6510,7 +6915,7 @@ function registerCode(program) {
     let mockReply;
     if (opts.mock) {
       try {
-        mockReply = fs7.readFileSync(opts.mock, "utf8");
+        mockReply = fs10.readFileSync(opts.mock, "utf8");
       } catch {
         throw new CliError(`couldn't read the --mock file: ${opts.mock}`, ExitCode.USAGE_ERROR);
       }
@@ -6558,20 +6963,20 @@ function registerCode(program) {
         process.stdout.write(JSON.stringify(line) + "\n");
       };
       try {
-        const { RunOutcomeRecorder, newOneShotRunId, turnRunId } = await import('./run-outcome-QWLNBASF.js');
+        const { RunOutcomeRecorder, newOneShotRunId, turnRunId } = await import('./run-outcome-AMIKAASL.js');
         const primarySlug = route.providers[0]?.model.includes("/") ? route.providers[0].model.split("/")[0] : route.providers[0]?.id;
-        const { runCodeStreamJson, parseHostMessage } = await import('./stream-json-GM44SP7L.js');
-        const { nodeCodeFs } = await import('./session-MG6BJVAG.js');
-        const readline5 = await import('readline');
+        const { runCodeStreamJson, parseHostMessage } = await import('./stream-json-A6K2MONY.js');
+        const { nodeCodeFs } = await import('./session-SCHQQTHN.js');
+        const readline6 = await import('readline');
         const child = await import('child_process');
         const { loadOrDiscoverFederation } = await import('./federation-MDQPO3PW.js');
         const { resolveExecutionEnv } = await import('./execution-env-4MS5AYAN.js');
         const { resolveModelExecutionProfile, mergeModelExecutionProfile } = await import('./model-execution-profile-ELWF3Z6H.js');
-        const { startCodeRuntimeSession } = await import('./runtime-session-UQ7UVAPL.js');
-        const { resolveGraphBackend } = await import('./graph-backend-I4I72J4W.js');
+        const { startCodeRuntimeSession } = await import('./runtime-session-QAVOPSSH.js');
+        const { resolveGraphBackend } = await import('./graph-backend-WF4LGBGD.js');
         const { detectGitRef } = await import('./git-ref-RSRAN4OH.js');
         const { repositoryIdFromRoot } = await import('./paths-62AKTFSR.js');
-        const { vgdRequest: vgdRequest2 } = await import('./vgd-ZUSBEVUL.js');
+        const { vgdRequest: vgdRequest2 } = await import('./vgd-B67JCNJP.js');
         const federation = loadOrDiscoverFederation(root2);
         const modelProfile = mergeModelExecutionProfile(
           resolveModelExecutionProfile({
@@ -6629,7 +7034,7 @@ ${res.stderr}` : ""),
             exitCode: res.status ?? 1
           };
         };
-        const { createVgBuiltinMcpTools, mergeExternalToolsets } = await import('./vg-mcp-bridge-3WFC7LGE.js');
+        const { createVgBuiltinMcpTools, mergeExternalToolsets } = await import('./vg-mcp-bridge-3TSFOL4V.js');
         const vgBuiltin = createVgBuiltinMcpTools({
           getGraph: () => graph,
           root: root2,
@@ -6653,7 +7058,7 @@ ${res.stderr}` : ""),
         const os4 = await import('os');
         const pathMod = await import('path');
         const checkpointIndex = pathMod.join(
-          fs7.mkdtempSync(pathMod.join(os4.tmpdir(), "vg-code-cp-")),
+          fs10.mkdtempSync(pathMod.join(os4.tmpdir(), "vg-code-cp-")),
           "index"
         );
         const gitRunner = (gitArgs, gitEnv) => {
@@ -6703,6 +7108,8 @@ ${res.stderr}` : ""),
           capsule,
           files: opts.file.length ? opts.file : void 0,
           worktreeOverlay: true,
+          // Real-model host: compaction writes a model checkpoint summary.
+          llmCompaction: true,
           // Full coding agent: free discovery by default. Capsule is context only.
           advancedMode: true,
           externalTools,
@@ -6717,15 +7124,16 @@ ${res.stderr}` : ""),
         };
         try {
           if (opts.session) {
-            const { runCodeStreamJsonSession } = await import('./stream-json-GM44SP7L.js');
-            const { runAgent: runAgent2 } = await import('./agent-4DAECASW.js');
+            const { runCodeStreamJsonSession } = await import('./stream-json-A6K2MONY.js');
+            const { runAgent: runAgent2 } = await import('./agent-JTA4YWMQ.js');
             const {
+              condenseSession,
               loadLatestSession,
               newSession,
               recordTask,
               saveSession,
               summarizeSession
-            } = await import('./session-store-SQECEXUU.js');
+            } = await import('./session-store-F7NX7SZN.js');
             const resumedRecord = opts.continue ? loadLatestSession(root2) : void 0;
             let record = resumedRecord ?? newSession(
               `s${Date.now().toString(36)}`,
@@ -6736,13 +7144,13 @@ ${res.stderr}` : ""),
             const pendingTurns = [];
             let wakeTurn;
             let ended = false;
-            const pushTurn = (instruction2) => {
+            const pushTurn = (turn) => {
               if (wakeTurn) {
                 const wake = wakeTurn;
                 wakeTurn = void 0;
-                wake(instruction2);
-              } else if (instruction2 !== null) {
-                pendingTurns.push(instruction2);
+                wake(turn);
+              } else if (turn !== null) {
+                pendingTurns.push(turn);
               }
             };
             const nextTurn = () => {
@@ -6763,7 +7171,7 @@ ${res.stderr}` : ""),
               nextTurn,
               bindDecisions: (session) => {
                 streamApprove = (action) => session.approve(action);
-                const rl = readline5.createInterface({ input: process.stdin });
+                const rl = readline6.createInterface({ input: process.stdin });
                 rl.on("line", (raw) => {
                   const msg = parseHostMessage(raw);
                   if (!msg) return;
@@ -6771,7 +7179,8 @@ ${res.stderr}` : ""),
                     session.submitDecision(msg.id, msg.approve);
                     runOutcome.noteDecision(msg.id, msg.approve);
                   } else if (msg.kind === "answer") session.submitAnswer(msg.id, msg.answer);
-                  else if (msg.kind === "submit") pushTurn(msg.instruction);
+                  else if (msg.kind === "submit")
+                    pushTurn({ instruction: msg.instruction, agentMode: msg.agentMode, images: msg.images });
                   else if (msg.kind === "restore") {
                     void import('./checkpoint-4WFZMKEO.js').then(({ restoreCheckpoint }) => {
                       const outcome = restoreCheckpoint(gitRunner, {
@@ -6780,6 +7189,14 @@ ${res.stderr}` : ""),
                       });
                       emitStream({ event: "checkpoint-restored", commit: msg.commit, ...outcome });
                     });
+                  } else if (msg.kind === "compact") {
+                    record = condenseSession(record, Date.now());
+                    saveSession(root2, record);
+                    emitStream({
+                      event: "event",
+                      type: "notice",
+                      text: "Conversation compacted \u2014 earlier turns condensed into a checkpoint."
+                    });
                   } else if (msg.kind === "cancel") {
                     session.cancelTurn();
                     runOutcome.cancelPending();
@@ -6795,14 +7212,24 @@ ${res.stderr}` : ""),
                   pushTurn(null);
                 });
               },
-              runTurn: ({ instruction: turnInstruction, priorSummary, signal, session }) => {
+              runTurn: ({ instruction: turnInstruction, signal, session, agentMode, auto: turnAuto, images }) => {
+                const priorSummary = summarizeSession(record) || void 0;
                 turnIndex++;
                 runOutcome.beginRun(turnRunId(record.id, turnIndex), turnInstruction);
+                const plan = agentMode === "plan";
+                streamApprove = plan ? async () => false : (action) => session.approve(action);
                 return runAgent2({
                   ...baseAgentOptions,
                   instruction: turnInstruction,
                   priorSummary,
+                  // Carry-over for capsule seed ranking: the previous
+                  // turn's instruction (the current turn is recorded only
+                  // in onTurnEnd, so .at(-1) is the prior ask).
+                  priorInstruction: record.tasks.at(-1)?.instruction,
                   signal,
+                  auto: turnAuto,
+                  plan,
+                  images,
                   approve: session.approve,
                   askUser: session.askUser,
                   onEvent: session.onEvent
@@ -6831,7 +7258,7 @@ ${res.stderr}` : ""),
               emit: emitAndRecord,
               bindDecisions: (session) => {
                 streamApprove = (action) => session.approve(action);
-                const rl = readline5.createInterface({ input: process.stdin });
+                const rl = readline6.createInterface({ input: process.stdin });
                 rl.on("line", (raw) => {
                   const msg = parseHostMessage(raw);
                   if (!msg) return;
@@ -6866,17 +7293,21 @@ ${res.stderr}` : ""),
       if (!autonomous && !tty) {
         throw usageError("the agent approves each edit/command \u2014 run in a terminal to approve interactively, or pass --auto to run autonomously (or --single for a one-shot diff).");
       }
-      const { agentTask } = await import('./interactive-TMQR6TXM.js');
-      const { nodeCodeFs } = await import('./session-MG6BJVAG.js');
+      const { agentTask } = await import('./interactive-6PN237LX.js');
+      const { nodeCodeFs } = await import('./session-SCHQQTHN.js');
       const { TtyPrompter } = await import('./ui-K7D3BCHD.js');
       let priorSummary;
+      let priorInstruction;
       if (opts.continue) {
-        const { loadLatestSession, summarizeSession } = await import('./session-store-SQECEXUU.js');
+        const { loadLatestSession, summarizeSession } = await import('./session-store-F7NX7SZN.js');
         const prev = loadLatestSession(root2);
-        if (prev) priorSummary = summarizeSession(prev);
+        if (prev) {
+          priorSummary = summarizeSession(prev);
+          priorInstruction = prev.tasks.at(-1)?.instruction;
+        }
       }
       const prompter = tty ? new TtyPrompter() : void 0;
-      const { createVgBuiltinMcpTools, mergeExternalToolsets } = await import('./vg-mcp-bridge-3WFC7LGE.js');
+      const { createVgBuiltinMcpTools, mergeExternalToolsets } = await import('./vg-mcp-bridge-3TSFOL4V.js');
       const vgBuiltin = createVgBuiltinMcpTools({
         getGraph: () => graph,
         root: root2,
@@ -6900,11 +7331,11 @@ ${res.stderr}` : ""),
         const { loadFederation } = await import('./federation-MDQPO3PW.js');
         const { resolveExecutionEnv } = await import('./execution-env-4MS5AYAN.js');
         const { resolveModelExecutionProfile, mergeModelExecutionProfile } = await import('./model-execution-profile-ELWF3Z6H.js');
-        const { startCodeRuntimeSession } = await import('./runtime-session-UQ7UVAPL.js');
-        const { resolveGraphBackend } = await import('./graph-backend-I4I72J4W.js');
+        const { startCodeRuntimeSession } = await import('./runtime-session-QAVOPSSH.js');
+        const { resolveGraphBackend } = await import('./graph-backend-WF4LGBGD.js');
         const { detectGitRef } = await import('./git-ref-RSRAN4OH.js');
         const { repositoryIdFromRoot } = await import('./paths-62AKTFSR.js');
-        const { vgdRequest: vgdRequest2 } = await import('./vgd-ZUSBEVUL.js');
+        const { vgdRequest: vgdRequest2 } = await import('./vgd-B67JCNJP.js');
         const federation = loadFederation(root2);
         const modelProfile = mergeModelExecutionProfile(
           resolveModelExecutionProfile({
@@ -6954,13 +7385,15 @@ ${res.stderr}` : ""),
             stream: opts.stream,
             verify: verify3 ? { command: verify3.command, maxRounds: modelProfile.maxRepairRounds } : void 0,
             priorSummary,
+            priorInstruction,
             externalTools: mcpTools,
             prompter,
             capsule,
             files: opts.file.length ? opts.file : void 0,
             executionEnv,
             graphBackend,
-            modelProfile
+            modelProfile,
+            llmCompaction: true
           });
           if (global.json) json(agentResult);
           if (agentResult.stopped === "error") process.exitCode = ExitCode.ERROR;
@@ -6974,7 +7407,7 @@ ${res.stderr}` : ""),
     }
     let consent = !!opts.yes;
     if (opts.apply && !consent && process.stdin.isTTY && process.stdout.isTTY) {
-      consent = await confirm(`Apply the proposed change to ${root2}?`);
+      consent = await confirm2(`Apply the proposed change to ${root2}?`);
     }
     const onPhase = (phase, detail) => {
       if (!global.json && !global.quiet) info(c.dim(`  ${phase}: ${detail}`));
@@ -6996,7 +7429,7 @@ ${res.stderr}` : ""),
       attribution: { client: "vg-code", provider: providerSlug, model: primary?.model }
     });
     if (opts.out) {
-      fs7.writeFileSync(opts.out, JSON.stringify(result, null, 2) + "\n");
+      fs10.writeFileSync(opts.out, JSON.stringify(result, null, 2) + "\n");
     }
     if (global.json) {
       json(result);
@@ -7047,7 +7480,7 @@ function resolveSecurityTierFlag(flag, fromConfig, auto) {
   if (fromConfig) return fromConfig;
   return auto ? "L1" : "L0";
 }
-function confirm(question) {
+function confirm2(question) {
   return new Promise((resolve21) => {
     const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
     rl.question(`${question} [y/N] `, (answer) => {
@@ -7209,7 +7642,7 @@ async function addCmd(root2, rest, opts, asJson) {
 }
 function readPackageVersion(root2) {
   try {
-    const pkg = JSON.parse(fs7__default.readFileSync(path37__default.join(root2, "package.json"), "utf8"));
+    const pkg = JSON.parse(fs10__default.readFileSync(path39__default.join(root2, "package.json"), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : void 0;
   } catch {
     return void 0;
@@ -7217,7 +7650,7 @@ function readPackageVersion(root2) {
 }
 function readOptionalFile(p) {
   try {
-    const t = fs7__default.readFileSync(p, "utf8");
+    const t = fs10__default.readFileSync(p, "utf8");
     return t.trim() ? t : void 0;
   } catch {
     return void 0;
@@ -7232,8 +7665,8 @@ async function publishCmd(root2, rest, opts, global, asJson) {
   if (!parsed) throw new CliError("publishing a private library requires a DSN \u2014 run `vibgrate login` or set VIBGRATE_DSN", ExitCode.USAGE_ERROR);
   const version = (opts.version || readPackageVersion(root2) || "").trim();
   if (!version) throw usageError("a --version is required (or run from a package whose package.json has a version)");
-  const readme = readOptionalFile(opts.readme ? path37__default.resolve(opts.readme) : path37__default.join(root2, "README.md"));
-  const dts = opts.dts ? readOptionalFile(path37__default.resolve(opts.dts)) : void 0;
+  const readme = readOptionalFile(opts.readme ? path39__default.resolve(opts.readme) : path39__default.join(root2, "README.md"));
+  const dts = opts.dts ? readOptionalFile(path39__default.resolve(opts.dts)) : void 0;
   if (!readme && !dts) throw usageError("nothing to publish \u2014 no README.md found and no --dts given");
   const result = await publishPrivateLibrary(
     { name, version, readme, dts, language: opts.language },
@@ -7365,8 +7798,8 @@ function registerExport(program) {
       out(content.trimEnd());
       return;
     }
-    fs7.mkdirSync(path37.dirname(path37.resolve(file)), { recursive: true });
-    fs7.writeFileSync(file, content);
+    fs10.mkdirSync(path39.dirname(path39.resolve(file)), { recursive: true });
+    fs10.writeFileSync(file, content);
     info(`${c.green("\u2714")} wrote ${file} ${c.dim(`(${format})`)}`);
   });
   applyGlobalOptions(cmd);
@@ -7376,43 +7809,43 @@ function detectFormat(file) {
   if (lower.endsWith(".cdx.json")) return "cyclonedx";
   if (lower.endsWith(".spdx.json")) return "spdx";
   if (file === "-") return "json";
-  return formatForExt(path37.extname(file));
+  return formatForExt(path39.extname(file));
 }
 function registerBundle(program) {
   const cmd = program.command("bundle").description("build an air-gapped bundle (grammars + graph + library catalog)").option("--offline", "offline bundle (default; present for clarity)").option("-o, --out <dir>", "output directory", "vg-bundle").action(function(opts) {
     const global = readGlobal(this);
     const root2 = rootOf(global);
-    const outDir = path37.resolve(root2, opts.out ?? "vg-bundle");
+    const outDir = path39.resolve(root2, opts.out ?? "vg-bundle");
     let grammarFiles;
     try {
       grammarFiles = resolvedGrammarFiles();
     } catch {
       throw new CliError("no grammars found to bundle (run a build first)", ExitCode.ERROR);
     }
-    fs7.mkdirSync(path37.join(outDir, "grammars"), { recursive: true });
+    fs10.mkdirSync(path39.join(outDir, "grammars"), { recursive: true });
     let grammarCount = 0;
     for (const { fileName, absPath } of grammarFiles) {
-      fs7.copyFileSync(absPath, path37.join(outDir, "grammars", fileName));
+      fs10.copyFileSync(absPath, path39.join(outDir, "grammars", fileName));
       grammarCount++;
     }
     const included = [`grammars/ (${grammarCount} .wasm)`];
     const graphSrc = resolveGraphPath(root2, global.graph);
-    if (fs7.existsSync(graphSrc)) {
-      fs7.copyFileSync(graphSrc, path37.join(outDir, "graph.json"));
+    if (fs10.existsSync(graphSrc)) {
+      fs10.copyFileSync(graphSrc, path39.join(outDir, "graph.json"));
       included.push("graph.json");
     } else {
       const graph = loadGraphFileWithSnapshot(graphSrc);
       if (graph) {
-        fs7.writeFileSync(path37.join(outDir, "graph.json"), serializeGraph(graph));
+        fs10.writeFileSync(path39.join(outDir, "graph.json"), serializeGraph(graph));
         included.push("graph.json");
       }
     }
     const cat = catalogPath(root2);
-    if (fs7.existsSync(cat)) {
-      fs7.copyFileSync(cat, path37.join(outDir, "vibgrate.lib.json"));
+    if (fs10.existsSync(cat)) {
+      fs10.copyFileSync(cat, path39.join(outDir, "vibgrate.lib.json"));
       included.push("vibgrate.lib.json");
-      if (fs7.existsSync(libDir(root2))) {
-        fs7.cpSync(libDir(root2), path37.join(outDir, "lib"), { recursive: true });
+      if (fs10.existsSync(libDir(root2))) {
+        fs10.cpSync(libDir(root2), path39.join(outDir, "lib"), { recursive: true });
         included.push("lib/");
       }
     }
@@ -7424,15 +7857,15 @@ function registerBundle(program) {
       included,
       usage: "Run `vg build --grammars <this dir>/grammars` to build fully offline."
     };
-    fs7.writeFileSync(path37.join(outDir, "MANIFEST.json"), `${stableStringify(manifest, 2)}
+    fs10.writeFileSync(path39.join(outDir, "MANIFEST.json"), `${stableStringify(manifest, 2)}
 `);
     if (global.json) {
-      json({ out: path37.relative(root2, outDir), ...manifest });
+      json({ out: path39.relative(root2, outDir), ...manifest });
       return;
     }
-    info(`${c.cyan("vg bundle")} \xB7 wrote ${path37.relative(root2, outDir)}/`);
+    info(`${c.cyan("vg bundle")} \xB7 wrote ${path39.relative(root2, outDir)}/`);
     for (const i of included) info(`  ${c.green("\u2714")} ${i}`);
-    info(c.dim(`  offline: vg build --grammars "${path37.relative(root2, outDir)}/grammars"`));
+    info(c.dim(`  offline: vg build --grammars "${path39.relative(root2, outDir)}/grammars"`));
   });
   applyGlobalOptions(cmd);
 }
@@ -7450,7 +7883,7 @@ async function runDoctor(global) {
   const root2 = rootOf(global);
   const local = global.local === true;
   const graphPath = resolveGraphPath(root2, global.graph);
-  const configFile = CONFIG_BASENAMES.find((f) => fs7.existsSync(path37.join(root2, f))) ?? null;
+  const configFile = CONFIG_BASENAMES.find((f) => fs10.existsSync(path39.join(root2, f))) ?? null;
   const graph = loadGraph(root2, graphPath);
   let staleFiles = null;
   if (graph) {
@@ -7476,14 +7909,14 @@ async function runDoctor(global) {
     root: root2,
     configFile,
     map: {
-      path: path37.relative(root2, graphPath),
+      path: path39.relative(root2, graphPath),
       built: graph !== null,
       generatedAt: graph?.generatedAt ?? null,
       staleFiles
     },
     libCatalog: {
-      path: path37.relative(root2, catalogPath(root2)),
-      present: fs7.existsSync(catalogPath(root2)),
+      path: path39.relative(root2, catalogPath(root2)),
+      present: fs10.existsSync(catalogPath(root2)),
       libraries: libCount
     },
     credentials: creds,
@@ -7540,7 +7973,7 @@ async function runDoctor(global) {
   );
   info(
     `  host pool  ${li.hostPool.size} warm session(s)` + (li.hostPool.sessions[0] ? c.dim(
-      ` \xB7 last ${path37.basename(li.hostPool.sessions[0].modelPath)} kv=${li.hostPool.sessions[0].kvBlocks}`
+      ` \xB7 last ${path39.basename(li.hostPool.sessions[0].modelPath)} kv=${li.hostPool.sessions[0].kvBlocks}`
     ) : c.dim(" \xB7 none (load via vg code / vgd host-load)"))
   );
   if (li.dynamicOnToken || li.dynamicCustomSampler) {
@@ -7716,7 +8149,7 @@ function registerDaemon(program) {
   const register = cmd.command("register").description("register the current repository with a running vgd").argument("[root]", "repository root (default: cwd)").action(async function(rootArg) {
     const global = readGlobal(this);
     const socketPath = socketOf(this);
-    const root2 = path37.resolve(rootArg ?? rootOf(global));
+    const root2 = path39.resolve(rootArg ?? rootOf(global));
     if (!await vgdIsRunning({ socketPath })) {
       throw new CliError(`vgd is not running \u2014 start it with \`vg daemon start\` (${socketPath})`, ExitCode.NOT_FOUND);
     }
@@ -7752,7 +8185,7 @@ function registerDaemon(program) {
   const federation = cmd.command("federation").description("register a multi-root federation from .vibgrate/federation.json (or primary cwd)").argument("[root]", "primary repository root (default: cwd)").action(async function(rootArg) {
     const global = readGlobal(this);
     const socketPath = socketOf(this);
-    const primary = path37.resolve(rootArg ?? rootOf(global));
+    const primary = path39.resolve(rootArg ?? rootOf(global));
     if (!await vgdIsRunning({ socketPath })) {
       throw new CliError(`vgd is not running \u2014 start it with \`vg daemon start\` (${socketPath})`, ExitCode.NOT_FOUND);
     }
@@ -7780,7 +8213,7 @@ function registerDaemon(program) {
   const publish = cmd.command("publish").description("load the workspace code map into vgd ActiveGraph (from global/legacy store)").argument("[root]", "repository root (default: cwd)").option("--git-ref <ref>", "branch or SHA (default: detect HEAD)").action(async function(rootArg) {
     const global = readGlobal(this);
     const socketPath = socketOf(this);
-    const root2 = path37.resolve(rootArg ?? rootOf(global));
+    const root2 = path39.resolve(rootArg ?? rootOf(global));
     if (!await vgdIsRunning({ socketPath })) {
       throw new CliError(`vgd is not running \u2014 start it with \`vg daemon ensure\` (${socketPath})`, ExitCode.NOT_FOUND);
     }
@@ -7794,7 +8227,7 @@ function registerDaemon(program) {
       throw new CliError(loaded.error, ExitCode.NOT_FOUND);
     }
     if (!loaded.ok) {
-      const { loadGraph: loadGraph2 } = await import('./load-E3OTM7BS.js');
+      const { loadGraph: loadGraph2 } = await import('./load-T2FOJUPI.js');
       const { detectGitRef } = await import('./git-ref-RSRAN4OH.js');
       const { repositoryIdFromRoot } = await import('./paths-62AKTFSR.js');
       const graph = loadGraph2(root2, global.graph);
@@ -7910,7 +8343,7 @@ function socketOf(cmd) {
   let c2 = cmd;
   while (c2) {
     const opts = c2.opts();
-    if (opts.socket) return path37.resolve(opts.socket);
+    if (opts.socket) return path39.resolve(opts.socket);
     c2 = c2.parent;
   }
   return vgdSocketPath();
@@ -7982,7 +8415,7 @@ async function restartVgdIfRunning(socketPath = vgdSocketPath()) {
 }
 function readVgdPid() {
   try {
-    const raw = fs7.readFileSync(vgdPidPath(), "utf8").trim();
+    const raw = fs10.readFileSync(vgdPidPath(), "utf8").trim();
     const pid = Number.parseInt(raw, 10);
     return Number.isInteger(pid) && pid > 0 ? pid : null;
   } catch {
@@ -8067,7 +8500,7 @@ function registerPolicy(program) {
     const global = readGlobal(this);
     let raw;
     try {
-      raw = fs7.readFileSync(file, "utf8");
+      raw = fs10.readFileSync(file, "utf8");
     } catch {
       throw new CliError(`cannot read ${file}`, ExitCode.NOT_FOUND);
     }
@@ -8187,11 +8620,11 @@ function registerLlmHost(program) {
   applyGlobalOptions(cmd);
 }
 var initCommand = new Command("init").description("Initialize vibgrate in a project").argument("[path]", "Path to initialize", ".").option("--baseline", "Create initial baseline after init").option("--yes", "Skip confirmation prompts").action(async (targetPath, opts) => {
-  const rootDir = path37.resolve(targetPath);
-  const vibgrateDir2 = path37.join(rootDir, ".vibgrate");
+  const rootDir = path39.resolve(targetPath);
+  const vibgrateDir2 = path39.join(rootDir, ".vibgrate");
   await ensureDir(vibgrateDir2);
   console.log(chalk7.green("\u2714") + ` Created ${chalk7.bold(".vibgrate/")} directory`);
-  const configPath = path37.join(rootDir, "vibgrate.config.ts");
+  const configPath = path39.join(rootDir, "vibgrate.config.ts");
   if (await pathExists(configPath)) {
     console.log(chalk7.dim("  vibgrate.config.ts already exists, skipping"));
   } else {
@@ -8199,7 +8632,7 @@ var initCommand = new Command("init").description("Initialize vibgrate in a proj
     console.log(chalk7.green("\u2714") + ` Created ${chalk7.bold("vibgrate.config.ts")}`);
   }
   if (opts.baseline) {
-    const { runBaseline } = await import('./baseline-4BDH4F2W.js');
+    const { runBaseline } = await import('./baseline-2V7PKA7Q.js');
     await runBaseline(rootDir);
   }
   console.log("");
@@ -8302,7 +8735,7 @@ function collectPackageImports(graph, ecosystem, pkg) {
   };
 }
 async function firstReferenceLine(rootDir, relFile, identifier, readFile3) {
-  const content = await readFile3(path37.join(rootDir, relFile));
+  const content = await readFile3(path39.join(rootDir, relFile));
   if (!content) return null;
   const escaped = identifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const re = new RegExp(`\\b${escaped}\\b`);
@@ -8340,9 +8773,9 @@ function sitesFromImportFiles(files, limit = 10) {
 }
 async function defaultReadFile(absPath) {
   try {
-    const stat2 = await fs21.stat(absPath);
+    const stat2 = await fs24.stat(absPath);
     if (!stat2.isFile() || stat2.size > MAX_FILE_BYTES) return null;
-    return await fs21.readFile(absPath, "utf8");
+    return await fs24.readFile(absPath, "utf8");
   } catch {
     return null;
   }
@@ -8538,7 +8971,7 @@ var AI_ASSISTANT_DETECTORS = [
 async function detectAiAssistant(rootDir) {
   for (const detector of AI_ASSISTANT_DETECTORS) {
     for (const file of detector.files) {
-      if (await pathExists$1(path37.join(rootDir, file))) {
+      if (await pathExists$1(path39.join(rootDir, file))) {
         return detector.name;
       }
     }
@@ -8732,7 +9165,7 @@ var scanCommand = new Command("scan").description("Scan a project for upgrade dr
   collectExcludes,
   []
 ).option("--concurrency <n>", "Max concurrent npm calls", "8").option("--push", "Auto-push results to Vibgrate API after scan").option("--dsn <dsn>", "DSN token for push (or use VIBGRATE_DSN env)").option("--region <region>", "Override data residency region for push (us, eu)").option("--strict", "Fail on push errors").option("--ui-purpose", "Enable optional UI purpose evidence extraction (slower)").option("--no-local-artifacts", "Do not write .vibgrate JSON artifacts to disk").option("--max-privacy", "Enable strongest privacy mode (minimal scanners, no local artifacts)").option("--offline", "Run without network calls; do not upload results").option("--full", "Comprehensive scan: turns on known-vulnerability detection (= --vulns) and, when a standards policy exists, a banned-dependency report \u2014 on top of drift scoring and the code map").option("--vulns", "Also scan installed dependencies for known vulnerabilities (OSV online, or advisories from --package-manifest when offline)").option("--package-manifest <file>", "Use local package-version manifest JSON/ZIP (for offline mode)").option("--project-scan-timeout <seconds>", "Per-project scan timeout in seconds (default: 180)").option("--drift-budget <score>", "Fail if DriftScore is above budget (0-100)").option("--drift-worsening <percent>", "Fail if drift worsens by more than % since baseline").option("--repository-name <name>", "Override the repository name recorded for this scan (defaults to the directory or package.json name)").option("--force", "Always create a fresh scan ingest, even if the repository is unchanged since the last scan (skips the unchanged/reuse optimization). Used by scheduled and dashboard-triggered scans.").option("--no-graph", "Skip building the local code map (the AI/docs index) that scan produces after scoring drift").option("--quiet", "Suppress promotional output (the free-plan tracking panel and the AI Context install prompt); scan results are unaffected").action(async (targetPath, opts) => {
-  const rootDir = path37.resolve(targetPath);
+  const rootDir = path39.resolve(targetPath);
   if (!await pathExists$1(rootDir)) {
     console.error(chalk7.red(`Path does not exist: ${rootDir}`));
     process.exit(1);
@@ -8740,7 +9173,7 @@ var scanCommand = new Command("scan").description("Scan a project for upgrade dr
   const hasDsn = !!resolveDsn(opts.dsn);
   const willPush = !opts.offline && (opts.push || hasDsn);
   const noLocalArtifacts = opts.localArtifacts === false;
-  const isFirstRun = !await pathExists$1(path37.join(rootDir, ".vibgrate", "scan_result.json"));
+  const isFirstRun = !await pathExists$1(path39.join(rootDir, ".vibgrate", "scan_result.json"));
   let pinnedRegion;
   let planTier;
   let upgradeUrl;
@@ -8999,7 +9432,7 @@ var SKIP_DIRS2 = /* @__PURE__ */ new Set([
 function scanStaleness(rootDir, artifactPath) {
   let ref;
   try {
-    ref = fs7.statSync(artifactPath).mtimeMs;
+    ref = fs10.statSync(artifactPath).mtimeMs;
   } catch {
     return { stale: false };
   }
@@ -9011,7 +9444,7 @@ function scanStaleness(rootDir, artifactPath) {
     if (depth > 8 || scanned > MAX_ENTRIES2) return;
     let entries;
     try {
-      entries = fs7.readdirSync(dir, { withFileTypes: true });
+      entries = fs10.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -9019,20 +9452,20 @@ function scanStaleness(rootDir, artifactPath) {
       scanned++;
       if (scanned > MAX_ENTRIES2) break;
       if (e.isDirectory()) {
-        if (!SKIP_DIRS2.has(e.name) && !e.name.startsWith(".")) walk2(path37.join(dir, e.name), depth + 1);
+        if (!SKIP_DIRS2.has(e.name) && !e.name.startsWith(".")) walk2(path39.join(dir, e.name), depth + 1);
         continue;
       }
       if (!WATCHED_FILES.has(e.name) && !WATCHED_EXT.test(e.name)) continue;
-      const abs = path37.join(dir, e.name);
+      const abs = path39.join(dir, e.name);
       let mtimeMs;
       try {
-        mtimeMs = fs7.statSync(abs).mtimeMs;
+        mtimeMs = fs10.statSync(abs).mtimeMs;
       } catch {
         continue;
       }
       if (mtimeMs > newest) {
         newest = mtimeMs;
-        newestChanged = path37.relative(rootDir, abs) || e.name;
+        newestChanged = path39.relative(rootDir, abs) || e.name;
       }
     }
   };
@@ -9163,7 +9596,7 @@ function analyzeTree(root2, packages) {
     if (depth > MAX_DEPTH || filesSeen >= MAX_FILES) return;
     let entries;
     try {
-      entries = fs7.readdirSync(dir, { withFileTypes: true });
+      entries = fs10.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -9172,17 +9605,17 @@ function analyzeTree(root2, packages) {
       if (filesSeen >= MAX_FILES) return;
       if (entry.isDirectory()) {
         if (SKIP_DIRS3.has(entry.name) || entry.name.startsWith(".")) continue;
-        walk2(path37.join(dir, entry.name), depth + 1);
+        walk2(path39.join(dir, entry.name), depth + 1);
         continue;
       }
-      const fileEco = EXT_ECOSYSTEM[path37.extname(entry.name)];
+      const fileEco = EXT_ECOSYSTEM[path39.extname(entry.name)];
       if (!fileEco || fileEco === "unknown") continue;
       filesSeen++;
-      const full = path37.join(dir, entry.name);
+      const full = path39.join(dir, entry.name);
       let content;
       try {
-        if (fs7.statSync(full).size > MAX_FILE_BYTES2) continue;
-        content = fs7.readFileSync(full, "utf8");
+        if (fs10.statSync(full).size > MAX_FILE_BYTES2) continue;
+        content = fs10.readFileSync(full, "utf8");
       } catch {
         continue;
       }
@@ -9493,7 +9926,7 @@ function applyPlan(rootDir, upgrades, opts = {}) {
     }
     const outcomes = effective.map((t) => {
       const c2 = pmCommandFor(u.ecosystem, u.package, u.to, opts.packageManager, { workspaceRoot: t.isWorkspaceRoot });
-      return { t, res: run(c2, path37.join(rootDir, t.dir)) };
+      return { t, res: run(c2, path39.join(rootDir, t.dir)) };
     });
     const failures = outcomes.filter((o) => !o.res.ok);
     if (failures.length === 0) {
@@ -9522,8 +9955,8 @@ function applyPlan(rootDir, upgrades, opts = {}) {
   return results;
 }
 var REGISTRY_URL = "https://registry.npmjs.org/@vibgrate%2fcli/latest";
-var CACHE_DIR = path37.join(os.homedir(), ".vibgrate");
-var CACHE_FILE = path37.join(CACHE_DIR, "update-check.json");
+var CACHE_DIR = path39.join(os.homedir(), ".vibgrate");
+var CACHE_FILE = path39.join(CACHE_DIR, "update-check.json");
 async function fetchLatestVersion() {
   try {
     const controller = new AbortController();
@@ -9550,8 +9983,8 @@ async function fetchLatestVersion() {
 }
 async function writeCache(data) {
   try {
-    await fs21.mkdir(CACHE_DIR, { recursive: true });
-    await fs21.writeFile(CACHE_FILE, JSON.stringify(data), "utf-8");
+    await fs24.mkdir(CACHE_DIR, { recursive: true });
+    await fs24.writeFile(CACHE_FILE, JSON.stringify(data), "utf-8");
   } catch {
   }
 }
@@ -9562,7 +9995,7 @@ function detectGlobalInstall(execPath = process.argv[1] || "", cwd = process.cwd
   if (!execPath) return null;
   let resolved = execPath;
   try {
-    resolved = fs7.realpathSync(execPath);
+    resolved = fs10.realpathSync(execPath);
   } catch {
   }
   const p = resolved.replace(/\\/g, "/");
@@ -9592,14 +10025,14 @@ async function findGlobalInstall(pkg = PACKAGE_NAME, run = defaultRunner) {
       pm: "yarn",
       root: () => {
         const dir = tryRun("yarn global dir");
-        return dir ? path37.join(dir, "node_modules") : null;
+        return dir ? path39.join(dir, "node_modules") : null;
       }
     },
-    { pm: "bun", root: () => path37.join(os.homedir(), ".bun", "install", "global", "node_modules") }
+    { pm: "bun", root: () => path39.join(os.homedir(), ".bun", "install", "global", "node_modules") }
   ];
   for (const probe of probes) {
     const root2 = probe.root();
-    if (root2 && await pathExists(path37.join(root2, pkg))) return probe.pm;
+    if (root2 && await pathExists(path39.join(root2, pkg))) return probe.pm;
   }
   return null;
 }
@@ -9618,15 +10051,15 @@ function getGlobalUpdateCommand(pm, pkg, version) {
   }
 }
 async function detectPackageManager(cwd) {
-  if (await pathExists(path37.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (await pathExists(path37.join(cwd, "bun.lockb"))) return "bun";
-  if (await pathExists(path37.join(cwd, "yarn.lock"))) return "yarn";
+  if (await pathExists(path39.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (await pathExists(path39.join(cwd, "bun.lockb"))) return "bun";
+  if (await pathExists(path39.join(cwd, "yarn.lock"))) return "yarn";
   return "npm";
 }
 async function detectWorkspaceRoot(cwd) {
-  if (await pathExists(path37.join(cwd, "pnpm-workspace.yaml"))) return true;
+  if (await pathExists(path39.join(cwd, "pnpm-workspace.yaml"))) return true;
   try {
-    const pkgPath = path37.join(cwd, "package.json");
+    const pkgPath = path39.join(cwd, "package.json");
     const raw = await (await import('fs/promises')).readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(raw);
     return pkg.workspaces != null;
@@ -9651,7 +10084,7 @@ function getInstallCommand(pm, pkg, version, isDev, opts = {}) {
 }
 async function getLocalDependencyState(cwd, pkg = PACKAGE_NAME) {
   try {
-    const pkgPath = path37.join(cwd, "package.json");
+    const pkgPath = path39.join(cwd, "package.json");
     const raw = await (await import('fs/promises')).readFile(pkgPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.devDependencies?.[pkg]) return "dev";
@@ -9820,13 +10253,13 @@ function collectCandidates(artifact) {
   return out2;
 }
 var defaultFixScanner = async (rootDir) => {
-  const scratch = path37.join(os.tmpdir(), `vg-fix-scan-${process.pid}.json`);
+  const scratch = path39.join(os.tmpdir(), `vg-fix-scan-${process.pid}.json`);
   const scanOpts = { vibgrateVersion: VERSION, format: "json", out: scratch, quiet: true, concurrency: 8 };
   const advanced = await loadAdvancedScanHook();
   return runCoreScan(rootDir, scanOpts, advanced);
 };
 async function loadArtifact(rootDir, inFile, scan = defaultFixScanner) {
-  const artifactPath = path37.isAbsolute(inFile) ? inFile : path37.join(rootDir, inFile);
+  const artifactPath = path39.isAbsolute(inFile) ? inFile : path39.join(rootDir, inFile);
   if (await pathExists(artifactPath)) {
     const staleness = scanStaleness(rootDir, artifactPath);
     if (!staleness.stale) {
@@ -9853,7 +10286,7 @@ async function repositoryIdentity(rootDir, override) {
   }
 }
 var fixCommand = new Command("fix").description("Get ranked, risk-tiered upgrade plans from the hosted planner and optionally apply them (prompts before changing files; --yes applies non-interactively, --dry-run previews, --no-apply only prints). Requires login/DSN.").argument("[path]", "Path to analyse", ".").option("--in <file>", "Scan artifact to read", ".vibgrate/scan_result.json").option("--format <format>", "Output format (text|json|md)", "text").option("--dsn <dsn>", 'DSN token (or use VIBGRATE_DSN env / "vg login")').option("--region <region>", "Override data residency region (us, eu)").option("--repository-name <name>", "Override the repository name recorded for this plan").option("--plan <tier>", "Apply a specific plan non-interactively (safe|balanced|aggressive)").option("--yes", "Apply the recommended plan without prompting").option("--dry-run", "Show what would change without applying").option("--no-apply", "Only print the plans; never modify the project").option("--fail-on-vulns <severity>", "Exit non-zero if the recommended plan leaves an advisory at/above this severity unresolved (low|moderate|high|critical)").action(async (targetPath, opts) => {
-  const rootDir = path37.resolve(targetPath);
+  const rootDir = path39.resolve(targetPath);
   if (!await pathExists(rootDir)) {
     console.error(chalk7.red(`Path does not exist: ${rootDir}`));
     process.exit(1);
@@ -10014,7 +10447,7 @@ function emit(report, format) {
   }
 }
 function relProjectDir(rootDir, projectPath) {
-  const rel = path37.isAbsolute(projectPath) ? path37.relative(rootDir, projectPath) : projectPath;
+  const rel = path39.isAbsolute(projectPath) ? path39.relative(rootDir, projectPath) : projectPath;
   return rel === "" ? "." : rel;
 }
 async function buildTargetResolver(rootDir, artifact) {
@@ -10849,7 +11282,7 @@ function formatMarkdown(artifact) {
 
 // src/reporting/commands/report.ts
 var reportCommand = new Command("report").description("Generate a drift report from a scan artifact").option("--in <file>", "Input artifact file", ".vibgrate/scan_result.json").option("--format <format>", "Output format (md|text|json)", "text").action(async (opts) => {
-  const artifactPath = path37.resolve(opts.in);
+  const artifactPath = path39.resolve(opts.in);
   if (!await pathExists(artifactPath)) {
     console.error(chalk7.red(`Artifact not found: ${artifactPath}`));
     console.error(chalk7.dim('Run "vibgrate scan" first to generate a scan artifact.'));
@@ -10898,8 +11331,8 @@ function openUrl(url) {
 // src/reporting/commands/login.ts
 var delay = (ms) => new Promise((resolve21) => setTimeout(resolve21, ms));
 function isInside(dir, file) {
-  const rel = path37.relative(dir, file);
-  return !!rel && !rel.startsWith("..") && !path37.isAbsolute(rel);
+  const rel = path39.relative(dir, file);
+  return !!rel && !rel.startsWith("..") && !path39.isAbsolute(rel);
 }
 var loginCommand = new Command("login").description("Authenticate the CLI with your Vibgrate workspace via the browser").option("--ingest <url>", "Ingest API URL (overrides --region)").option("--region <region>", `Data residency region (${availableRegionIds().join(", ")})`, "us").option("--no-browser", "Do not attempt to open a browser automatically").option(
   "--local",
@@ -11154,7 +11587,7 @@ var vexCommand = new Command("vex").description("Generate an OpenVEX document (e
   try {
     const statements = [];
     if (opts.from) {
-      const fromPath = path37.resolve(opts.from);
+      const fromPath = path39.resolve(opts.from);
       if (!await pathExists(fromPath)) {
         process.stderr.write(chalk7.red(`Statements file not found: ${fromPath}
 `));
@@ -11172,9 +11605,9 @@ var vexCommand = new Command("vex").description("Generate an OpenVEX document (e
     });
     const json2 = JSON.stringify(doc, null, 2);
     if (opts.out) {
-      await writeTextFile(path37.resolve(opts.out), json2 + "\n");
+      await writeTextFile(path39.resolve(opts.out), json2 + "\n");
       process.stderr.write(
-        chalk7.green("\u2714") + ` Wrote OpenVEX document (${doc.statements.length} statement(s)) to ${path37.resolve(opts.out)}
+        chalk7.green("\u2714") + ` Wrote OpenVEX document (${doc.statements.length} statement(s)) to ${path39.resolve(opts.out)}
 `
       );
     } else {
@@ -11357,7 +11790,7 @@ function formatDeltaText(base, current) {
   return lines.join("\n");
 }
 async function readArtifactOrExit(filePath) {
-  const absolutePath = path37.resolve(filePath);
+  const absolutePath = path39.resolve(filePath);
   if (!await pathExists(absolutePath)) {
     console.error(chalk7.red(`Artifact not found: ${absolutePath}`));
     process.exit(1);
@@ -11374,7 +11807,7 @@ var exportCommand = new Command("export").description("Export scan artifact as S
   const sbom = format === "cyclonedx" ? toCycloneDx(artifact) : toSpdx(artifact);
   const body = JSON.stringify(sbom, null, 2);
   if (opts.out) {
-    await writeTextFile(path37.resolve(opts.out), body);
+    await writeTextFile(path39.resolve(opts.out), body);
     console.log(chalk7.green("\u2714") + ` SBOM written to ${opts.out}`);
   } else {
     console.log(body);
@@ -11385,7 +11818,7 @@ var deltaCommand = new Command("delta").description("Show SBOM delta between two
   const current = await readArtifactOrExit(opts.to);
   const report = formatDeltaText(base, current);
   if (opts.out) {
-    await writeTextFile(path37.resolve(opts.out), report);
+    await writeTextFile(path39.resolve(opts.out), report);
     console.log(chalk7.green("\u2714") + ` SBOM delta report written to ${opts.out}`);
   } else {
     console.log(report);
@@ -11516,20 +11949,20 @@ function resolveRegime(id) {
   return regime;
 }
 function evidenceDir(root2) {
-  return path37.join(root2, ".vibgrate", "evidence");
+  return path39.join(root2, ".vibgrate", "evidence");
 }
 function orgPath(root2) {
-  return path37.join(evidenceDir(root2), "org.json");
+  return path39.join(evidenceDir(root2), "org.json");
 }
 function productsPath(root2) {
-  return path37.join(evidenceDir(root2), "products.json");
+  return path39.join(evidenceDir(root2), "products.json");
 }
 function releasesDir(root2) {
-  return path37.join(evidenceDir(root2), "releases");
+  return path39.join(evidenceDir(root2), "releases");
 }
 function releasePath(root2, productId, version) {
   const safe = `${productId}@${version}`.replace(/[^A-Za-z0-9._@-]/g, "_");
-  return path37.join(releasesDir(root2), `${safe}.json`);
+  return path39.join(releasesDir(root2), `${safe}.json`);
 }
 var DEFAULT_ORG = {
   responsiblePersons: [],
@@ -11560,7 +11993,7 @@ async function freezeRelease(root2, release) {
   const p = releasePath(root2, release.productId, release.version);
   if (await pathExists(p)) {
     throw new CliError(
-      `release ${release.productId}@${release.version} is already frozen and manifests are immutable \u2014 delete ${path37.relative(root2, p)} only if it was frozen in error`,
+      `release ${release.productId}@${release.version} is already frozen and manifests are immutable \u2014 delete ${path39.relative(root2, p)} only if it was frozen in error`,
       ExitCode.USAGE_ERROR
     );
   }
@@ -11574,7 +12007,7 @@ async function loadReleases(root2, productId) {
   const files = (await readdir(dir)).filter((f) => f.endsWith(".json")).sort();
   const releases = [];
   for (const f of files) {
-    const rel = await readJsonFile(path37.join(dir, f));
+    const rel = await readJsonFile(path39.join(dir, f));
     if (!productId || rel.productId === productId) releases.push(rel);
   }
   return releases;
@@ -12269,19 +12702,19 @@ function verifyEvidenceEnvelope(env, opts = {}) {
 var DEFAULT_KEY = "attest-key.pem";
 function resolveSigningKey(root2, explicit) {
   const chosen = process.env.VG_ATTEST_KEY;
-  const keyPath = chosen ? path37.resolve(chosen) : path37.join(root2, ".vibgrate", DEFAULT_KEY);
+  const keyPath = chosen ? path39.resolve(chosen) : path39.join(root2, ".vibgrate", DEFAULT_KEY);
   let minted = false;
-  if (!fs7.existsSync(keyPath)) {
+  if (!fs10.existsSync(keyPath)) {
     if (chosen) throw new CliError(`signing key not found: ${chosen}`, ExitCode.USAGE_ERROR);
     const kp = generateKeypair();
-    fs7.mkdirSync(path37.dirname(keyPath), { recursive: true });
-    fs7.writeFileSync(keyPath, kp.privatePem, { mode: 384 });
-    fs7.writeFileSync(`${keyPath}.pub`, kp.publicPem);
+    fs10.mkdirSync(path39.dirname(keyPath), { recursive: true });
+    fs10.writeFileSync(keyPath, kp.privatePem, { mode: 384 });
+    fs10.writeFileSync(`${keyPath}.pub`, kp.publicPem);
     minted = true;
   }
   let key2;
   try {
-    key2 = crypto3.createPrivateKey(fs7.readFileSync(keyPath, "utf8"));
+    key2 = crypto3.createPrivateKey(fs10.readFileSync(keyPath, "utf8"));
   } catch {
     throw new CliError(`could not read an Ed25519 private key from ${keyPath}`, ExitCode.USAGE_ERROR);
   }
@@ -12292,16 +12725,16 @@ function resolveSigningKey(root2, explicit) {
 }
 function writeBundle(input) {
   const dir = input.outDir;
-  fs7.mkdirSync(path37.join(dir, "inputs", "releases"), { recursive: true });
-  const write = (rel, data) => fs7.writeFileSync(path37.join(dir, rel), `${JSON.stringify(data, null, 2)}
+  fs10.mkdirSync(path39.join(dir, "inputs", "releases"), { recursive: true });
+  const write = (rel, data) => fs10.writeFileSync(path39.join(dir, rel), `${JSON.stringify(data, null, 2)}
 `);
   write("result.json", input.result);
-  write(path37.join("inputs", "advisory.json"), input.advisory);
+  write(path39.join("inputs", "advisory.json"), input.advisory);
   for (const rel of input.releases) {
     const safe = `${rel.productId}@${rel.version}`.replace(/[^A-Za-z0-9._@-]/g, "_");
-    write(path37.join("inputs", "releases", `${safe}.json`), rel);
+    write(path39.join("inputs", "releases", `${safe}.json`), rel);
   }
-  write(path37.join("inputs", "datapack.lock"), { dataPackVersion: input.result.meta.dataPackVersion, kernelVersion: input.result.meta.kernelVersion });
+  write(path39.join("inputs", "datapack.lock"), { dataPackVersion: input.result.meta.dataPackVersion, kernelVersion: input.result.meta.kernelVersion });
   write("provenance.json", {
     method: "deterministic",
     modelDrafted: [],
@@ -12317,13 +12750,13 @@ function writeBundle(input) {
     disclaimer: input.regime.disclaimer
   });
   if (input.envelope) {
-    fs7.writeFileSync(path37.join(dir, "evidence.intoto.jsonl"), `${JSON.stringify(input.envelope)}
+    fs10.writeFileSync(path39.join(dir, "evidence.intoto.jsonl"), `${JSON.stringify(input.envelope)}
 `);
   }
   if (input.timestampToken) {
-    fs7.writeFileSync(path37.join(dir, "timestamp.tsr"), input.timestampToken);
+    fs10.writeFileSync(path39.join(dir, "timestamp.tsr"), input.timestampToken);
   }
-  fs7.writeFileSync(path37.join(dir, "VERIFY.md"), verifyDoc(input));
+  fs10.writeFileSync(path39.join(dir, "VERIFY.md"), verifyDoc(input));
   return dir;
 }
 function verifyDoc(input) {
@@ -12384,13 +12817,13 @@ function undeterminedFields(result, regime) {
   return gaps.filter((g) => regime.submission.requires.some((r) => g.startsWith(r)) || g.startsWith("exposure") || g.startsWith("member"));
 }
 async function recordDrill(root2, record) {
-  const dir = path37.join(evidenceDir(root2), "drills");
-  const p = path37.join(dir, `${record.drillId}.json`);
+  const dir = path39.join(evidenceDir(root2), "drills");
+  const p = path39.join(dir, `${record.drillId}.json`);
   await writeJsonFile(p, record);
   return p;
 }
 async function hasRecentDrill(root2, asOf) {
-  const dir = path37.join(evidenceDir(root2), "drills");
+  const dir = path39.join(evidenceDir(root2), "drills");
   if (!await pathExists(dir)) return void 0;
   const { readdir } = await import('fs/promises');
   const { readJsonFile: readJsonFile2 } = await import('./fs-4G5A65KS.js');
@@ -12398,7 +12831,7 @@ async function hasRecentDrill(root2, asOf) {
   if (files.length === 0) return void 0;
   const cutoff = new Date(new Date(asOf).getTime() - 90 * 24 * 3600 * 1e3).toISOString();
   for (const f of files) {
-    const rec = await readJsonFile2(path37.join(dir, f));
+    const rec = await readJsonFile2(path39.join(dir, f));
     if (rec.ranAt >= cutoff) return true;
   }
   return false;
@@ -12478,7 +12911,7 @@ function formatRegimeList() {
 
 // src/reporting/commands/evidence/index.ts
 function root(opts) {
-  return path37.resolve(opts.cwd ?? process.cwd());
+  return path39.resolve(opts.cwd ?? process.cwd());
 }
 function slug(name) {
   return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "product";
@@ -12566,7 +12999,7 @@ var releaseCmd = new Command("release").description("Freeze a shipped release in
   const release = await buildRelease({
     productId: product.id,
     version,
-    from: path37.resolve(rootDir, opts.from),
+    from: path39.resolve(rootDir, opts.from),
     shipDate: opts.shipDate,
     buildId: opts.buildId,
     artefactDigest: opts.digest,
@@ -12574,7 +13007,7 @@ var releaseCmd = new Command("release").description("Freeze a shipped release in
     frozenAt: nowIso()
   });
   const p = await freezeRelease(rootDir, release);
-  console.log(chalk7.green("\u2714") + ` froze ${chalk7.bold(`${product.id}@${version}`)} \u2014 ${release.components.length} components, immutable at ${path37.relative(rootDir, p)}`);
+  console.log(chalk7.green("\u2714") + ` froze ${chalk7.bold(`${product.id}@${version}`)} \u2014 ${release.components.length} components, immutable at ${path39.relative(rootDir, p)}`);
 });
 async function runExposure(rootDir, vuln, opts) {
   const org = await loadOrg(rootDir);
@@ -12626,7 +13059,7 @@ var exposureCmd = new Command("exposure").description("Which shipped products co
     console.log("\n" + buildPack(result, regime, org, stage));
   }
   if (opts.bundle) {
-    const dir = path37.resolve(rootDir, opts.bundle, `evidence-${result.meta.evidenceId}`);
+    const dir = path39.resolve(rootDir, opts.bundle, `evidence-${result.meta.evidenceId}`);
     let envelope;
     if (opts.sign !== false) {
       const { key: key2, minted } = resolveSigningKey(rootDir);
@@ -12634,7 +13067,7 @@ var exposureCmd = new Command("exposure").description("Which shipped products co
       envelope = signEvidenceStatement(buildEvidenceStatement(result, VERSION), key2);
     }
     writeBundle({ outDir: dir, result, advisory, releases, regime, envelope, timestampToken, cliVersion: VERSION });
-    console.error(chalk7.green("\u2714") + ` evidence bundle written to ${path37.relative(rootDir, dir)}${envelope ? " (signed)" : " (unsigned)"}${timestampToken ? " \xB7 RFC 3161" : ""}`);
+    console.error(chalk7.green("\u2714") + ` evidence bundle written to ${path39.relative(rootDir, dir)}${envelope ? " (signed)" : " (unsigned)"}${timestampToken ? " \xB7 RFC 3161" : ""}`);
   }
   process.exitCode = exposureExit(result.overallStatus);
 });
@@ -12666,7 +13099,7 @@ var packCmd = new Command("pack").description("Build the submission pack a human
   const stage = opts.stage ?? regime.clocks[0]?.stage ?? "early-warning";
   const md = buildPack(result, regime, org, stage);
   if (opts.out) {
-    fs7.writeFileSync(path37.resolve(rootDir, opts.out), md);
+    fs10.writeFileSync(path39.resolve(rootDir, opts.out), md);
     console.error(chalk7.green("\u2714") + ` pack written to ${opts.out}`);
   } else {
     console.log(md);
@@ -12708,20 +13141,20 @@ var drillCmd = new Command("drill").description("Timed dry-run of the determinat
   }
 });
 var verifyCmd = new Command("verify").description("Verify an evidence bundle offline (no Vibgrate needed)").argument("<bundle>", "Path to an evidence bundle directory or evidence.intoto.jsonl").option("--pub <file>", "Public key PEM to pin the signer (establish trust)").action((bundlePath, opts) => {
-  const abs = path37.resolve(bundlePath);
-  const envPath = fs7.statSync(abs).isDirectory() ? path37.join(abs, "evidence.intoto.jsonl") : abs;
-  if (!fs7.existsSync(envPath)) throw new CliError(`no evidence.intoto.jsonl at ${bundlePath}`, ExitCode.NOT_FOUND);
-  const envelope = JSON.parse(fs7.readFileSync(envPath, "utf8").trim().split("\n")[0]);
-  const resultPath = path37.join(path37.dirname(envPath), "result.json");
-  const result = fs7.existsSync(resultPath) ? JSON.parse(fs7.readFileSync(resultPath, "utf8")) : void 0;
-  const publicKeyPem = opts.pub ? fs7.readFileSync(path37.resolve(opts.pub), "utf8") : void 0;
+  const abs = path39.resolve(bundlePath);
+  const envPath = fs10.statSync(abs).isDirectory() ? path39.join(abs, "evidence.intoto.jsonl") : abs;
+  if (!fs10.existsSync(envPath)) throw new CliError(`no evidence.intoto.jsonl at ${bundlePath}`, ExitCode.NOT_FOUND);
+  const envelope = JSON.parse(fs10.readFileSync(envPath, "utf8").trim().split("\n")[0]);
+  const resultPath = path39.join(path39.dirname(envPath), "result.json");
+  const result = fs10.existsSync(resultPath) ? JSON.parse(fs10.readFileSync(resultPath, "utf8")) : void 0;
+  const publicKeyPem = opts.pub ? fs10.readFileSync(path39.resolve(opts.pub), "utf8") : void 0;
   const v = verifyEvidenceEnvelope(envelope, { publicKeyPem, result });
   const color = v.status === "verified" ? chalk7.green : v.status === "failed" ? chalk7.red : chalk7.yellow;
   console.log("  " + color(v.status.toUpperCase()) + `  ${v.reason}`);
   if (v.evidenceId) console.log("  " + chalk7.dim(`evidence ${v.evidenceId} \xB7 regime ${v.regime} \xB7 advisory ${v.advisoryId} \xB7 ${v.overallStatus}`));
-  const tsrPath = path37.join(path37.dirname(envPath), "timestamp.tsr");
-  if (fs7.existsSync(tsrPath) && result) {
-    const t = verifyTimestamp(fs7.readFileSync(tsrPath), exposureSubjectDigest(result));
+  const tsrPath = path39.join(path39.dirname(envPath), "timestamp.tsr");
+  if (fs10.existsSync(tsrPath) && result) {
+    const t = verifyTimestamp(fs10.readFileSync(tsrPath), exposureSubjectDigest(result));
     const tcolor = t.imprintMatches ? chalk7.green : chalk7.red;
     console.log("  " + tcolor("TIMESTAMP") + `  ${t.reason}`);
   }
@@ -12788,12 +13221,12 @@ var exportCmd = new Command("export").description("Air-gap bundle of all evidenc
   const releases = [];
   for (const list of releasesByProduct.values()) releases.push(...list);
   const report = computeReadiness({ regime, org, products, releasesByProduct, recentDrill: await hasRecentDrill(rootDir, today()) });
-  const dir = path37.resolve(rootDir, opts.out);
-  await writeJsonFile(path37.join(dir, "org.json"), org);
-  await writeJsonFile(path37.join(dir, "products.json"), products);
-  for (const r of releases) await writeJsonFile(path37.join(dir, "releases", `${r.productId}@${r.version}.json`.replace(/[^A-Za-z0-9._@-]/g, "_")), r);
-  await writeJsonFile(path37.join(dir, "readiness.json"), report);
-  console.error(chalk7.green("\u2714") + ` exported evidence state to ${path37.relative(rootDir, dir)} (${products.length} products, ${releases.length} frozen releases)`);
+  const dir = path39.resolve(rootDir, opts.out);
+  await writeJsonFile(path39.join(dir, "org.json"), org);
+  await writeJsonFile(path39.join(dir, "products.json"), products);
+  for (const r of releases) await writeJsonFile(path39.join(dir, "releases", `${r.productId}@${r.version}.json`.replace(/[^A-Za-z0-9._@-]/g, "_")), r);
+  await writeJsonFile(path39.join(dir, "readiness.json"), report);
+  console.error(chalk7.green("\u2714") + ` exported evidence state to ${path39.relative(rootDir, dir)} (${products.length} products, ${releases.length} frozen releases)`);
 });
 var pushCmd = new Command("push").description("Push the product registry (and an optional exposure result) to Vibgrate Cloud").option(...cwdOption).option("--dsn <dsn>", "DSN token (or use VIBGRATE_DSN env / `vg login`)").option("--regime <id>", "Reporting regime").option("--result <file>", "An exposure result.json (or a bundle dir) to include").option("--signed", "Mark the included exposure result as signed").option("--strict", "Fail on push errors").action(async (opts) => {
   const rootDir = root(opts);
@@ -12819,10 +13252,10 @@ var pushCmd = new Command("push").description("Push the product registry (and an
   }));
   let exposure;
   if (opts.result) {
-    const raw = path37.resolve(rootDir, opts.result);
-    const resultPath = fs7.existsSync(raw) && fs7.statSync(raw).isDirectory() ? path37.join(raw, "result.json") : raw;
-    if (!fs7.existsSync(resultPath)) throw new CliError(`no result.json at ${opts.result}`, ExitCode.NOT_FOUND);
-    exposure = JSON.parse(fs7.readFileSync(resultPath, "utf8"));
+    const raw = path39.resolve(rootDir, opts.result);
+    const resultPath = fs10.existsSync(raw) && fs10.statSync(raw).isDirectory() ? path39.join(raw, "result.json") : raw;
+    if (!fs10.existsSync(resultPath)) throw new CliError(`no result.json at ${opts.result}`, ExitCode.NOT_FOUND);
+    exposure = JSON.parse(fs10.readFileSync(resultPath, "utf8"));
   }
   const payload = { schemaVersion: "evidence-push-1", regime: regime.id, generatedAt: nowIso(), signed: Boolean(opts.signed), products: productPayload, exposure };
   const body = JSON.stringify(payload);
@@ -12880,6 +13313,7 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "serve",
   "lsp",
   "doctor",
+  "module",
   "daemon",
   "policy",
   "llm-host",
@@ -12887,6 +13321,7 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "uninstall",
   "share",
   "watch",
+  "hook",
   "help",
   // Drift-reporting verbs (merged from the Vibgrate CLI).
   "init",
@@ -12926,6 +13361,8 @@ ${aliasNote}Docs: https://vibgrate.com/help`;
   registerServe(program);
   registerLsp(program);
   registerInstall(program);
+  registerModule(program);
+  registerHook(program);
   registerShare(program);
   registerWatch(program);
   registerTests(program);
@@ -13012,7 +13449,7 @@ function dispatch(argv, cwd) {
   }
   const looksLikeQuestion = /\s/.test(first) || first.endsWith("?");
   if (looksLikeQuestion) return ["ask", ...args];
-  if (fs7.existsSync(path37.resolve(cwd, first))) {
+  if (fs10.existsSync(path39.resolve(cwd, first))) {
     return [hasBuildOnlyFlag(args) ? "build" : "scan", ...args];
   }
   const moved = MOVED_COMMANDS[first];
@@ -13057,9 +13494,9 @@ async function main(argv = process.argv) {
 }
 function readCwd(raw) {
   const i = raw.findIndex((a) => a === "-C" || a === "--cwd");
-  if (i >= 0 && raw[i + 1]) return path37.resolve(raw[i + 1]);
+  if (i >= 0 && raw[i + 1]) return path39.resolve(raw[i + 1]);
   const eq = raw.find((a) => a.startsWith("--cwd="));
-  if (eq) return path37.resolve(eq.slice("--cwd=".length));
+  if (eq) return path39.resolve(eq.slice("--cwd=".length));
   return process.cwd();
 }
 function handleError(err) {