@vibgrate/cli 2026.814.2 → 2026.817.1

package/dist/cli.js

@@ -1,59 +1,62 @@
 #!/usr/bin/env node
-import { fetchCatalog, resolveProviders } from './chunk-5GLQNMTI.js';
-import { telemetryOptOut, StatsSharer, statsEndpoint, isCI } from './chunk-7NMXE6KG.js';
-import { loadAdvancedScanHook, baselineCommand } from './chunk-TFAXW7VM.js';
-import { sha256Hex, generateKeypair, dssePae, DSSE_PAYLOAD_TYPE, keyId, registerBuild, readGlobal, applyGlobalOptions, ProgressBar, printLogo, runBuild } from './chunk-JCN6MSXQ.js';
-export { runBuild } from './chunk-JCN6MSXQ.js';
+import { fetchCatalog, resolveProviders } from './chunk-NHB53JTV.js';
+import { telemetryOptOut, StatsSharer, statsEndpoint, isCI } from './chunk-45AKSS4A.js';
+import { loadAdvancedScanHook, baselineCommand } from './chunk-2BURPMYA.js';
+import { sha256Hex, generateKeypair, dssePae, DSSE_PAYLOAD_TYPE, keyId, registerBuild, ProgressBar, printLogo, runBuild } from './chunk-JHLCKMKF.js';
+export { runBuild } from './chunk-JHLCKMKF.js';
+import { restartVgdIfRunning, stopVgd, registerDaemon, rootOf, requireGraph } from './chunk-FMS6G67U.js';
+import { readGlobal, applyGlobalOptions } from './chunk-OZ3IFXRD.js';
 import { disableColor, info, c, json, out } from './chunk-CT5BS56U.js';
-import { VGD_PROTOCOL_VERSION, startVgdServer } from './chunk-NKFXXP6W.js';
+import './chunk-OWSXI3PJ.js';
 import './chunk-IS7VTH2Q.js';
 import { defaultProcessEndpoint, startProcessHostServer, resolveInferenceIsolation } from './chunk-JFE7XCAE.js';
 import { clearHostSessionPool, acquireHostSession, generateOnSession, listHostSessions, hostSessionPoolSize } from './chunk-3LOWJSAF.js';
-import { runCodeSession } from './chunk-YQNTIBKS.js';
-import { CONTEXT_POLICY_VERSION, computeFcsReport, renderFcsReportMarkdown, createTrajectoryCollector, runAgent } from './chunk-IHXNOY3R.js';
+import { runCodeSession } from './chunk-UBEVY5UT.js';
+import { CONTEXT_POLICY_VERSION, computeFcsReport, renderFcsReportMarkdown, createTrajectoryCollector, runAgent } from './chunk-YL4OIUA5.js';
 import './chunk-543E6WDJ.js';
-import './chunk-TVDYEHIM.js';
-import './chunk-54RGT2T5.js';
-import { vgdSocketPath, vgdIsRunning, vgdRequest, vgdPidPath } from './chunk-RBIRXQR6.js';
+import './chunk-ZSECAGSU.js';
+import './chunk-RQAKBRAV.js';
+import './chunk-RBIRXQR6.js';
 import { buildIdentifierTrieFromGraph } from './chunk-5HYCB55P.js';
-import { parseReasoningEffort, summarizeDiffs, ScriptedProvider } from './chunk-N3XFY3PX.js';
+import { parseReasoningEffort, summarizeDiffs, ScriptedProvider } from './chunk-74UBGF4P.js';
 import './chunk-7AVYKZEM.js';
-import { buildModelInstallPlan } from './chunk-WHJMS7XC.js';
-import { ensurePackage, ensureUnavailableMessage } from './chunk-REIGWTTH.js';
-import { init_resolve_ollama, gatherSystemMemory, resolveOllamaBinary, hasOllamaBinary, resolve_ollama_exports } from './chunk-OWSFZQOP.js';
+import { buildModelInstallPlan } from './chunk-I5LP55B6.js';
+import { ensurePackage, ensureUnavailableMessage } from './chunk-3HNPVXUK.js';
+import { init_resolve_ollama, gatherSystemMemory, resolveOllamaBinary, hasOllamaBinary, resolve_ollama_exports } from './chunk-FJG5AXKZ.js';
 import { readOrchestratorState, writeOrchestratorState, parseMode, setDefaultMode, recommendMode, activePin, resolveMode, providerForBackend, QUALIFIED_PACKS, pinPack, unpinPack, buildOrchestratorStatus } from './chunk-NZELMYT4.js';
 import { fmt, estimateModelBytes } from './chunk-7N4Y3E47.js';
 import './chunk-IZDH67DX.js';
-import { serveStdio, isRelevantChange, exportGraph, GraphSource, createServer, formatForExt, RefreshScheduler } from './chunk-YNV5M3JW.js';
-import { refreshIfStale } from './chunk-IHLLWBZU.js';
-import { CliError, ExitCode, driftCount, ASSISTANTS, detectAssistants, isAssistantInstalled, usageError, detectServeLaunch, installAssistant, writeNavigationConfig, uninstallAssistant, engineUnavailable, buildGraph, writeSnapshot, probeFreshness, discover, assistantById, SMALL_REPO_FILES, isSkippedDirName, SKIP_FILES, SKIP_DIRS } from './chunk-TNROG5CO.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-WWGLVF7D.js';
+import { serveStdio, isRelevantChange, exportGraph, GraphSource, createServer, formatForExt, RefreshScheduler } from './chunk-A7EKFLAN.js';
+import { refreshIfStale } from './chunk-K267DHCF.js';
+import { driftCount, ASSISTANTS, detectAssistants, isAssistantInstalled, detectServeLaunch, installAssistant, writeNavigationConfig, uninstallAssistant, TOOLCHAIN_GRAMMARS, resolveToolchainGrammar, buildGraph, writeSnapshot, probeFreshness, discover, assistantById, SMALL_REPO_FILES, isSkippedDirName, SKIP_FILES, SKIP_DIRS } from './chunk-RJCRWQNS.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-FD2HPGX2.js';
 import { resolveIngestHost, dashHostForIngestHost, availableRegionIds, ingestHostForRegionId } from './chunk-HTLDXEHW.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-N6ZMZ5AI.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-ANYL7SUI.js';
+import { CliError, ExitCode, usageError, engineUnavailable } from './chunk-MS6V5XKB.js';
 import './chunk-VIWZ4QT7.js';
-import { inventory, enrichOnline, ECOSYSTEMS, catalogPath, libDir, loadCatalog, driftFor, addLibrary, resolveLib, libId, resolveVersion, readDoc, localPackageDocs, localApiSurface } from './chunk-7QDHQLUS.js';
+import { inventory, enrichOnline, ECOSYSTEMS, catalogPath, libDir, loadCatalog, driftFor, addLibrary, resolveLib, libId, resolveVersion, readDoc, localPackageDocs, localApiSurface } from './chunk-NQUWC2IA.js';
 import { resolveOne } from './chunk-J7LKEB2R.js';
-import { recordCliCall, CLI_TOOL_ALIASES, savingsLedgerPath, clearSavings, readSavings, readUsage, readModelSavings, CAPSULE_RANKING_VERSION, SAVINGS_TOOLS, sanitizeClient } from './chunk-DSUGC7F5.js';
-import { queryGraphSemantic, queryGraph, indexFor, impactOf } from './chunk-KGPX4EUN.js';
+import { recordCliCall, CLI_TOOL_ALIASES, savingsLedgerPath, clearSavings, readSavings, readUsage, readModelSavings, CAPSULE_RANKING_VERSION, SAVINGS_TOOLS, sanitizeClient } from './chunk-NKRWKCME.js';
+import { queryGraphSemantic, queryGraph, indexFor, impactOf } from './chunk-2TJ5EY4I.js';
 import { discoverModels } from './chunk-CQDUBAQY.js';
 import { freeBytesOnVolume, weightStoreDir, listCachedWeights, ensureWeightCached, catalogIntegrityReport } from './chunk-OV4KGXPD.js';
-import { loadGraph, loadGraphPreferIndex, SCHEMA_VERSION } from './chunk-WQLZSVNF.js';
+import { loadGraph, loadGraphPreferIndex, SCHEMA_VERSION } from './chunk-MIYXVY57.js';
 import './chunk-5I4VSBWQ.js';
 import { pathExists as pathExists$1, parseExcludePatterns } from './chunk-DT4KIVRI.js';
 import { ensureDir, pathExists, readJsonFile, writeTextFile, writeJsonFile } from './chunk-CRAMOEBE.js';
-import { init_cli_invocation, resolveCliInvocation, NPX_INVOCATION } from './chunk-3LSG7Z4I.js';
-import { resolvedGrammarFiles, grammarSetVersion } from './chunk-UTNNGKKX.js';
+import { init_cli_invocation, resolveCliInvocation, NPX_INVOCATION } from './chunk-EZ7UC5Y5.js';
+import { resolvedGrammarFiles, grammarSetVersion } from './chunk-6NOGNOE4.js';
 import './chunk-RXP66R2E.js';
-import { embeddingsCached, resolveEmbedModel, loadEmbedder, getNodeEmbeddings, unavailableMessage, countPending, modelCacheInfo, embeddingsPath, clearModelCache, withTimeout } from './chunk-X76VPOYH.js';
-import { cacheDir } from './chunk-2U37PFB2.js';
-import { resetRelevanceProviderCache, loadRelevanceProvider, relevanceModuleDir, resolveGraphPath, analyzeQuestion, loadTopicTags, renderReport, loadGraphFileWithSnapshot, serializeGraph, stableStringify, writeArtifacts, vibgrateDir, mapFileExists, parseGraph, ensureVibgrateGitignore } from './chunk-75LJM5XD.js';
-import { VERSION } from './chunk-2H2U3DC7.js';
+import { embeddingsCached, resolveEmbedModel, loadEmbedder, getNodeEmbeddings, unavailableMessage, countPending, modelCacheInfo, embeddingsPath, clearModelCache, withTimeout } from './chunk-2GSMCOIC.js';
+import { cacheDir } from './chunk-QPXVTQ7O.js';
+import { resetRelevanceProviderCache, loadRelevanceProvider, relevanceModuleDir, resolveGraphPath, analyzeQuestion, loadTopicTags, renderReport, loadGraphFileWithSnapshot, serializeGraph, stableStringify, writeArtifacts, vibgrateDir, mapFileExists, parseGraph, ensureVibgrateGitignore } from './chunk-ENFSSUNK.js';
+import { VERSION } from './chunk-PV76EO4G.js';
 import './chunk-BWPBB45M.js';
 import { canonicalize, hashString, hashBytes } from './chunk-JFGYT6BI.js';
 import './chunk-BPF3YX2U.js';
 import { __toCommonJS } from './chunk-Z6ZWNWWR.js';
-import * as fs12 from 'fs';
-import fs12__default, { realpathSync } from 'fs';
+import * as fs14 from 'fs';
+import fs14__default, { realpathSync } from 'fs';
 import * as path43 from 'path';
 import path43__default from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
@@ -67,7 +70,7 @@ import * as zlib from 'zlib';
 import * as crypto3 from 'crypto';
 import { randomUUID, createHash } from 'crypto';
 import chalk7 from 'chalk';
-import * as fs27 from 'fs/promises';
+import * as fs28 from 'fs/promises';
 
 init_cli_invocation();
 function registerStatus(program) {
@@ -80,7 +83,7 @@ async function runStatus(global) {
   const root2 = path43.resolve(global.cwd ?? ".");
   const graphPath = resolveGraphPath(root2, global.graph);
   const graph = loadGraph(root2, graphPath);
-  const hasCache = fs12.existsSync(path43.join(cacheDir(root2), "parse-cache.json"));
+  const hasCache = fs14.existsSync(path43.join(cacheDir(root2), "parse-cache.json"));
   let stale = null;
   let staleExact = false;
   if (graph) {
@@ -136,20 +139,6 @@ async function runStatus(global) {
   }
   if (vibgrateDir(root2)) ;
 }
-function rootOf(global) {
-  return path43.resolve(global.cwd ?? ".");
-}
-function requireGraph(global) {
-  const root2 = rootOf(global);
-  const graph = loadGraph(root2, global.graph);
-  if (!graph) {
-    throw new CliError(
-      `no map found \u2014 run \`vg\` to build one first` + (global.graph ? ` (looked at ${global.graph})` : ""),
-      ExitCode.NOT_FOUND
-    );
-  }
-  return { root: root2, graph };
-}
 
 // src/commands/ask.ts
 function registerAsk(program) {
@@ -256,7 +245,7 @@ function verdictPath(dir) {
 }
 function readVerdict(dir) {
   try {
-    const raw = JSON.parse(fs12.readFileSync(verdictPath(dir), "utf8"));
+    const raw = JSON.parse(fs14.readFileSync(verdictPath(dir), "utf8"));
     if (raw?.status !== "ok" && raw?.status !== "crashed") return null;
     if (raw.version !== VERSION) return null;
     return raw;
@@ -266,8 +255,8 @@ function readVerdict(dir) {
 }
 function writeVerdict(dir, verdict) {
   try {
-    fs12.mkdirSync(dir, { recursive: true });
-    fs12.writeFileSync(verdictPath(dir), JSON.stringify(verdict, null, 2) + "\n", "utf8");
+    fs14.mkdirSync(dir, { recursive: true });
+    fs14.writeFileSync(verdictPath(dir), JSON.stringify(verdict, null, 2) + "\n", "utf8");
   } catch {
   }
 }
@@ -275,7 +264,7 @@ function probeModuleUrl(from = import.meta.url) {
   const dir = path43.dirname(fileURLToPath(from));
   for (const name of ["embeddings.js", "index.js"]) {
     const candidate = path43.join(dir, name);
-    if (fs12.existsSync(candidate)) return pathToFileURL(candidate).href;
+    if (fs14.existsSync(candidate)) return pathToFileURL(candidate).href;
   }
   return pathToFileURL(path43.join(dir, "index.js")).href;
 }
@@ -296,7 +285,7 @@ function defaultRunProbe(timeoutMs) {
       })
       .catch(() => process.stdout.write('{"ok":false}'));
   `;
-  return new Promise((resolve23) => {
+  return new Promise((resolve21) => {
     const child = spawn(process.execPath, ["--input-type=module", "-e", script], {
       stdio: ["ignore", "pipe", "ignore"],
       // The probe must never inherit a debugger port or loader flags that would
@@ -309,7 +298,7 @@ function defaultRunProbe(timeoutMs) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve23({ signal, status, stdout });
+      resolve21({ signal, status, stdout });
     };
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
@@ -352,7 +341,7 @@ async function embedderHealth(options = {}) {
 }
 function clearEmbedderHealth(cacheDir2) {
   try {
-    fs12.unlinkSync(verdictPath(cacheDir2 ?? defaultCacheDir()));
+    fs14.unlinkSync(verdictPath(cacheDir2 ?? defaultCacheDir()));
   } catch {
   }
 }
@@ -1027,7 +1016,7 @@ function liveStatsDir(root2) {
 function reapOtherVersionServers(dir, keepVersion, now = Date.now(), kill = (pid, signal) => process.kill(pid, signal), selfPid = process.pid) {
   let entries;
   try {
-    entries = fs12.readdirSync(dir);
+    entries = fs14.readdirSync(dir);
   } catch {
     return [];
   }
@@ -1036,7 +1025,7 @@ function reapOtherVersionServers(dir, keepVersion, now = Date.now(), kill = (pid
     if (!/^serve-\d+\.json$/.test(name)) continue;
     let parsed;
     try {
-      parsed = JSON.parse(fs12.readFileSync(path43.join(dir, name), "utf8"));
+      parsed = JSON.parse(fs14.readFileSync(path43.join(dir, name), "utf8"));
     } catch {
       continue;
     }
@@ -1090,10 +1079,10 @@ var LiveStatsBus = class {
     this.lastWriteAt = now;
     const body = { pid: this.pid, updatedAt: now, version: VERSION, snapshot: snap };
     try {
-      fs12.mkdirSync(this.dir, { recursive: true });
+      fs14.mkdirSync(this.dir, { recursive: true });
       const tmp = `${this.file}.tmp`;
-      fs12.writeFileSync(tmp, JSON.stringify(body));
-      fs12.renameSync(tmp, this.file);
+      fs14.writeFileSync(tmp, JSON.stringify(body));
+      fs14.renameSync(tmp, this.file);
     } catch {
     }
   }
@@ -1104,7 +1093,7 @@ var LiveStatsBus = class {
   siblings(now = Date.now()) {
     let entries;
     try {
-      entries = fs12.readdirSync(this.dir);
+      entries = fs14.readdirSync(this.dir);
     } catch {
       return [];
     }
@@ -1114,14 +1103,14 @@ var LiveStatsBus = class {
       const file = path43.join(this.dir, name);
       let parsed;
       try {
-        parsed = JSON.parse(fs12.readFileSync(file, "utf8"));
+        parsed = JSON.parse(fs14.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 {
-          fs12.unlinkSync(file);
+          fs14.unlinkSync(file);
         } catch {
         }
         continue;
@@ -1133,7 +1122,7 @@ var LiveStatsBus = class {
   }
   unlinkOwn = () => {
     try {
-      fs12.unlinkSync(this.file);
+      fs14.unlinkSync(this.file);
     } catch {
     }
   };
@@ -1446,12 +1435,12 @@ var LedgerTail = class {
     if (size === this.offset) return;
     let chunk;
     try {
-      const fd = fs12.openSync(this.file, "r");
+      const fd = fs14.openSync(this.file, "r");
       try {
         chunk = Buffer.alloc(size - this.offset);
-        fs12.readSync(fd, chunk, 0, chunk.length, this.offset);
+        fs14.readSync(fd, chunk, 0, chunk.length, this.offset);
       } finally {
-        fs12.closeSync(fd);
+        fs14.closeSync(fd);
       }
     } catch {
       return;
@@ -1464,7 +1453,7 @@ var LedgerTail = class {
   }
   sizeOf() {
     try {
-      return fs12.statSync(this.file).size;
+      return fs14.statSync(this.file).size;
     } catch {
       return 0;
     }
@@ -1643,7 +1632,7 @@ async function serveHttp(graphPath, host, port, opts, freshness, onReady) {
       info(c.red(`vg serve: request error: ${err.message}`));
     }
   });
-  await new Promise((resolve23) => httpServer.listen(port, host, resolve23));
+  await new Promise((resolve21) => httpServer.listen(port, host, resolve21));
   info(c.dim(`vg \xB7 MCP server on http://${host}:${port}/mcp (read-only, local, ${freshness})`));
   onReady?.();
   await new Promise(() => {
@@ -1864,7 +1853,7 @@ function manifestHash(root2) {
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = fs12.readdirSync(dir, { withFileTypes: true });
+      entries = fs14.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -1880,7 +1869,7 @@ function manifestHash(root2) {
       if (!isManifest(abs) && !SKIP_FILES.has(base)) continue;
       try {
         const rel = path43.relative(root2, abs).split(path43.sep).join("/");
-        files.push({ rel, hash: hashBytes(fs12.readFileSync(abs)) });
+        files.push({ rel, hash: hashBytes(fs14.readFileSync(abs)) });
       } catch {
       }
     }
@@ -1899,7 +1888,7 @@ function isDependencyFile(root2, filePath) {
 }
 function loadScanCache(root2, key2) {
   try {
-    const raw = JSON.parse(fs12.readFileSync(cachePath(root2), "utf8"));
+    const raw = JSON.parse(fs14.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 };
     }
@@ -1909,8 +1898,8 @@ function loadScanCache(root2, key2) {
 }
 function writeScanCache(root2, key2, artifact) {
   try {
-    fs12.mkdirSync(cacheDir(root2), { recursive: true });
-    fs12.writeFileSync(
+    fs14.mkdirSync(cacheDir(root2), { recursive: true });
+    fs14.writeFileSync(
       cachePath(root2),
       stableStringify(
         { version: CACHE_VERSION, manifestHash: key2.manifestHash, toolVersion: key2.toolVersion, offline: key2.offline, artifact },
@@ -1937,7 +1926,7 @@ function parseLine(line) {
 }
 function readHistory(root2) {
   try {
-    return fs12.readFileSync(historyPath(root2), "utf8").split("\n").filter((l) => l.trim()).map(parseLine).filter((e) => e !== null);
+    return fs14.readFileSync(historyPath(root2), "utf8").split("\n").filter((l) => l.trim()).map(parseLine).filter((e) => e !== null);
   } catch {
     return [];
   }
@@ -1964,14 +1953,14 @@ function recordScore(root2, entry) {
       }
     }
     const file = historyPath(root2);
-    fs12.mkdirSync(path43.dirname(file), { recursive: true });
+    fs14.mkdirSync(path43.dirname(file), { recursive: true });
     ensureVibgrateGitignore(root2);
-    fs12.appendFileSync(file, `${JSON.stringify(entry)}
+    fs14.appendFileSync(file, `${JSON.stringify(entry)}
 `);
     const all = readHistory(root2);
     if (all.length > MAX_ENTRIES) {
       const kept = all.slice(-KEEP_ENTRIES);
-      fs12.writeFileSync(file, kept.map((e) => JSON.stringify(e)).join("\n") + "\n");
+      fs14.writeFileSync(file, kept.map((e) => JSON.stringify(e)).join("\n") + "\n");
     }
   } catch {
   }
@@ -1981,6 +1970,71 @@ function deltaFrom(prev, current) {
   if (prev.methodology !== current.methodology) return void 0;
   return current.score - prev.score;
 }
+function ignoreFilePath(root2) {
+  return path43.join(root2, ".vibgrate", "ignore.json");
+}
+function isActive(entry, now = Date.now()) {
+  if (!entry.until) return true;
+  const t = Date.parse(entry.until);
+  if (!Number.isFinite(t)) return true;
+  return now <= t + 24 * 60 * 60 * 1e3 - 1;
+}
+function readIgnores(root2, now = Date.now()) {
+  const out2 = /* @__PURE__ */ new Map();
+  let raw;
+  try {
+    raw = fs14.readFileSync(ignoreFilePath(root2), "utf8");
+  } catch {
+    return out2;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.ignores)) return out2;
+    for (const e of parsed.ignores) {
+      const entry = e;
+      if (typeof entry.package !== "string" || !entry.package.trim()) continue;
+      const clean = { package: entry.package.trim() };
+      if (typeof entry.reason === "string" && entry.reason.trim()) clean.reason = entry.reason.trim();
+      if (typeof entry.until === "string" && entry.until.trim()) clean.until = entry.until.trim();
+      if (isActive(clean, now)) out2.set(clean.package.toLowerCase(), clean);
+    }
+  } catch {
+  }
+  return out2;
+}
+function inventoryPath(root2) {
+  return path43.join(root2, ".vibgrate", "inline-inventory.json");
+}
+function inventoryKey(projectPath, pkg) {
+  return `${projectPath}::${pkg}`;
+}
+function readInventory(root2) {
+  try {
+    const parsed = JSON.parse(fs14.readFileSync(inventoryPath(root2), "utf8"));
+    if (typeof parsed.ts === "string" && typeof parsed.methodology === "string" && Array.isArray(parsed.drifted) && parsed.drifted.every((d) => typeof d === "string")) {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+function recordInventory(root2, snap) {
+  try {
+    ensureVibgrateGitignore(root2);
+    fs14.writeFileSync(inventoryPath(root2), `${JSON.stringify(snap)}
+`);
+  } catch {
+  }
+}
+function newlyDrifted(prev, current) {
+  const out2 = /* @__PURE__ */ new Set();
+  if (!prev || prev.methodology !== current.methodology || prev.ts === current.ts) return out2;
+  const before = new Set(prev.drifted);
+  for (const key2 of current.drifted) {
+    if (!before.has(key2)) out2.add(key2);
+  }
+  return out2;
+}
 
 // src/lsp/graph-query.ts
 function semanticBudgetMs() {
@@ -2511,6 +2565,10 @@ var VibgrateLanguageServer = class {
   docs = /* @__PURE__ */ new Map();
   // uri → text
   artifact = null;
+  /** Active `.vibgrate/ignore.json` entries, refreshed once per scan. */
+  ignores = /* @__PURE__ */ new Map();
+  /** `project.path::package` drifted now but not in the previous snapshot. */
+  newDrift = /* @__PURE__ */ new Set();
   scanning = false;
   queued = false;
   /**
@@ -2711,6 +2769,18 @@ var VibgrateLanguageServer = class {
     };
     const delta = deltaFrom(lastEntry(this.opts.root), historyEntry);
     recordScore(this.opts.root, historyEntry);
+    this.ignores = readIgnores(this.opts.root);
+    const driftedKeys = [];
+    for (const proj of a.projects ?? []) {
+      for (const dep of proj.dependencies ?? []) {
+        if (dep.drift === "major-behind" || dep.drift === "minor-behind") {
+          driftedKeys.push(inventoryKey(proj.path, dep.package));
+        }
+      }
+    }
+    const snapshot = { ts: a.timestamp, methodology: historyEntry.methodology, drifted: driftedKeys };
+    this.newDrift = newlyDrifted(readInventory(this.opts.root), snapshot);
+    recordInventory(this.opts.root, snapshot);
     const payload = {
       score: a.drift.score,
       band,
@@ -2744,12 +2814,19 @@ var VibgrateLanguageServer = class {
       if (dep.drift === "current" || dep.drift === "unknown") continue;
       const line = findPackageLine(text, dep.package, kind);
       if (line === -1) continue;
+      const ignored = this.ignores.get(dep.package.toLowerCase());
+      const isNew = project ? this.newDrift.has(inventoryKey(project.path, dep.package)) : false;
       items.push({
         line,
         endCol: endOfLine(text, line),
-        text: inlineLabel(dep),
-        band: bandForDependency(dep),
-        package: dep.package
+        text: inlineLabel(dep, { ignored: !!ignored, isNew }),
+        // An acknowledged ignore stops shouting: the engine calms the band to
+        // low (presentation only — the score is untouched). The client still
+        // never derives a band; it renders this one.
+        band: ignored ? "low" : bandForDependency(dep),
+        package: dep.package,
+        ...ignored ? { ignored: true } : {},
+        ...isNew ? { newSincePrev: true } : {}
       });
     }
     this.conn.notify("vibgrate/inline", { uri, items });
@@ -2757,7 +2834,10 @@ var VibgrateLanguageServer = class {
       this.conn.notify("textDocument/publishDiagnostics", { uri, diagnostics: [] });
       return;
     }
-    const diagnostics = (a.findings ?? []).filter((f) => DIAGNOSTIC_RULES.has(f.ruleId)).filter((f) => project && sameProject(f.location, project.path)).map((f) => {
+    const diagnostics = (a.findings ?? []).filter((f) => DIAGNOSTIC_RULES.has(f.ruleId)).filter((f) => project && sameProject(f.location, project.path)).filter((f) => {
+      const pkg = f.details?.["package"];
+      return !(typeof pkg === "string" && this.ignores.has(pkg.toLowerCase()));
+    }).map((f) => {
       const line = Math.max(0, findRuntimeLine(text, kind));
       return {
         range: {
@@ -2787,10 +2867,18 @@ var VibgrateLanguageServer = class {
     const dep = (project?.dependencies ?? []).find(
       (d) => findPackageLine(text, d.package, kind) === line
     );
-    if (!dep) return null;
+    if (!dep) {
+      if (project && line === Math.max(0, findRuntimeLine(text, kind))) {
+        const value = runtimeHoverMarkdown(project, a.findings ?? []);
+        return value ? { contents: { kind: "markdown", value } } : null;
+      }
+      return null;
+    }
     const contribution = a.drift.dependencyDrift?.top.find((t) => t.package === dep.package)?.drift ?? null;
+    const ignored = this.ignores.get(dep.package.toLowerCase());
+    const isNew = project ? this.newDrift.has(inventoryKey(project.path, dep.package)) : false;
     return {
-      contents: { kind: "markdown", value: hoverMarkdown(dep, contribution) }
+      contents: { kind: "markdown", value: hoverMarkdown(dep, contribution, { ignored, isNew }) }
     };
   }
   onCodeLens(params) {
@@ -2946,7 +3034,7 @@ var VibgrateLanguageServer = class {
       const absManifest = path43.resolve(this.opts.root, relManifest);
       let text = null;
       try {
-        if (fs12.existsSync(absManifest)) text = fs12.readFileSync(absManifest, "utf8");
+        if (fs14.existsSync(absManifest)) text = fs14.readFileSync(absManifest, "utf8");
       } catch {
         text = null;
       }
@@ -3220,7 +3308,7 @@ function buildBreakdown(rootDir, projects) {
     const absManifest = path43.resolve(rootDir, relManifest);
     let text = null;
     try {
-      if (fs12.existsSync(absManifest)) text = fs12.readFileSync(absManifest, "utf8");
+      if (fs14.existsSync(absManifest)) text = fs14.readFileSync(absManifest, "utf8");
     } catch {
       text = null;
     }
@@ -3285,34 +3373,34 @@ function buildBreakdown(rootDir, projects) {
 }
 function manifestRelativePath(proj) {
   const base = proj.path === "." || proj.path === "" ? "" : proj.path;
-  const join33 = (name) => base ? path43.join(base, name) : name;
+  const join35 = (name) => base ? path43.join(base, name) : name;
   switch (proj.type) {
     case "node":
     case "typescript":
-      return join33("package.json");
+      return join35("package.json");
     case "python":
-      return join33("pyproject.toml");
+      return join35("pyproject.toml");
     case "go":
-      return join33("go.mod");
+      return join35("go.mod");
     case "rust":
-      return join33("Cargo.toml");
+      return join35("Cargo.toml");
     case "ruby":
-      return join33("Gemfile");
+      return join35("Gemfile");
     case "php":
-      return join33("composer.json");
+      return join35("composer.json");
     case "java":
     case "kotlin":
     case "scala":
     case "groovy":
-      return join33("pom.xml");
+      return join35("pom.xml");
     case "dotnet":
-      return join33(proj.name ? `${proj.name}.csproj` : "Directory.Build.props");
+      return join35(proj.name ? `${proj.name}.csproj` : "Directory.Build.props");
     case "dart":
-      return join33("pubspec.yaml");
+      return join35("pubspec.yaml");
     case "elixir":
-      return join33("mix.exs");
+      return join35("mix.exs");
     default:
-      return join33("package.json");
+      return join35("package.json");
   }
 }
 function lockfileRelativePath(rootDir, proj) {
@@ -3345,7 +3433,7 @@ function lockfileRelativePath(rootDir, proj) {
     for (const name of candidateNames) {
       const rel = dir ? path43.join(dir, name) : name;
       try {
-        if (fs12.existsSync(path43.join(rootDir, rel))) return rel;
+        if (fs14.existsSync(path43.join(rootDir, rel))) return rel;
       } catch {
       }
     }
@@ -3417,9 +3505,9 @@ function lookupImportFiles(map, pkg) {
 function firstPackageMentionLine(root2, relFile, pkg) {
   try {
     const abs = path43.resolve(root2, relFile);
-    const stat2 = fs12.statSync(abs);
+    const stat2 = fs14.statSync(abs);
     if (!stat2.isFile() || stat2.size > 256 * 1024) return null;
-    const text = fs12.readFileSync(abs, "utf8");
+    const text = fs14.readFileSync(abs, "utf8");
     const tokens = [pkg];
     if (pkg.startsWith("@")) {
       const parts = pkg.split("/");
@@ -3479,8 +3567,11 @@ function inRangeStep(dep) {
   const diff2 = semver3.diff(dep.resolvedVersion, target);
   return { version: target, size: diff2 === "patch" || diff2 === "prepatch" ? "patch" : "minor" };
 }
-function inlineLabel(dep) {
+function inlineLabel(dep, state) {
   const bits = [];
+  if (state?.ignored) bits.push("ignored");
+  if (dep.unsupported) bits.push("unsupported");
+  else if (dep.abandoned) bits.push("abandoned");
   if (dep.drift === "major-behind") {
     const step2 = inRangeStep(dep);
     if (step2) bits.push(`${step2.size} behind`, step2.version);
@@ -3493,8 +3584,38 @@ function inlineLabel(dep) {
   if (dep.ageDays != null && dep.ageDays >= 1) {
     bits.push(`${Math.round(dep.ageDays).toLocaleString("en-US")}d stale`);
   }
+  if (state?.isNew) bits.push("new");
   return bits.join(" \xB7 ");
 }
+function runtimeHoverMarkdown(project, findings, now = Date.now()) {
+  const lines = [];
+  const label = runtimeHorizonLabel(project);
+  if (project.runtimeEolDate) {
+    const t = Date.parse(project.runtimeEolDate);
+    if (Number.isFinite(t)) {
+      const days = Math.round((t - now) / (24 * 60 * 60 * 1e3));
+      const when = days < 0 ? `**EOL ${project.runtimeEolDate}** \u2014 ${Math.abs(days).toLocaleString("en-US")} days ago` : `EOL ${project.runtimeEolDate} \u2014 in ${days.toLocaleString("en-US")} days`;
+      lines.push(`**${label}**`);
+      lines.push("");
+      lines.push(days < 0 ? `$(warning) ${when}` : when);
+    }
+  }
+  const runtimeFindings = findings.filter(
+    (f) => DIAGNOSTIC_RULES.has(f.ruleId) && (f.ruleId.startsWith("vibgrate/runtime") || f.ruleId === "vibgrate/eol")
+  ).filter((f) => sameProject(f.location, project.path));
+  if (runtimeFindings.length) {
+    if (!lines.length) {
+      lines.push(`**${label}**`);
+    }
+    lines.push("");
+    for (const f of runtimeFindings.slice(0, 4)) lines.push(`- ${f.message}`);
+  }
+  if (!lines.length) return null;
+  lines.push("");
+  lines.push("---");
+  lines.push("$(shield) EOL dates from the Runtime Catalog (endoflife.date). Resolved locally.");
+  return lines.join("\n");
+}
 function commandUri(command, args) {
   return `command:${command}?${encodeURIComponent(JSON.stringify([args]))}`;
 }
@@ -3515,12 +3636,23 @@ function versionJourney(yours, latest) {
   const shown = majors.length > 5 ? [majors[0], majors[1], -1, majors[majors.length - 2], majors[majors.length - 1]] : majors;
   return shown.map((m) => m === -1 ? "\u2026" : `${m}.x`).join(" \u2192 ");
 }
-function hoverMarkdown(dep, contribution) {
+function hoverMarkdown(dep, contribution, state) {
   const lines = [];
   const badge = driftBadge(dep);
   const contributionText = contribution != null ? ` \xB7 contributes +${Math.round(contribution)} to drift` : "";
   lines.push(badge ? `**${dep.package}**  \`${badge}\`${contributionText}` : `**${dep.package}**`);
   lines.push("");
+  if (state?.ignored) {
+    const ig = state.ignored;
+    const why = ig.reason ? ` \u2014 ${ig.reason}` : "";
+    const until = ig.until ? ` (until ${ig.until})` : "";
+    lines.push(`$(eye-closed) **Ignored**${why}${until} \xB7 \`.vibgrate/ignore.json\``);
+    lines.push("");
+  }
+  if (state?.isNew) {
+    lines.push("_New drift \u2014 this dependency was not behind in the previous recorded scan._");
+    lines.push("");
+  }
   const yours = dep.resolvedVersion ?? dep.currentSpec;
   const drifted = dep.drift === "major-behind" || dep.drift === "minor-behind";
   if (dep.latestStable && dep.latestStable !== yours) {
@@ -3571,7 +3703,7 @@ function hoverMarkdown(dep, contribution) {
   return lines.join("\n");
 }
 function startLanguageServer(opts) {
-  if (!fs12.existsSync(opts.root)) {
+  if (!fs14.existsSync(opts.root)) {
     process.stderr.write(`vg lsp: root does not exist: ${opts.root}
 `);
     process.exit(1);
@@ -3623,9 +3755,9 @@ function installClaudeHooks(root2, vgBin = "vg") {
   const file = path43.join(root2, ".claude", "settings.json");
   const rel = path43.join(".claude", "settings.json");
   let settings = {};
-  if (fs12.existsSync(file)) {
+  if (fs14.existsSync(file)) {
     try {
-      const parsed = JSON.parse(fs12.readFileSync(file, "utf8"));
+      const parsed = JSON.parse(fs14.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" };
       }
@@ -3664,10 +3796,10 @@ function installClaudeHooks(root2, vgBin = "vg") {
 function uninstallClaudeHooks(root2) {
   const file = path43.join(root2, ".claude", "settings.json");
   const rel = path43.join(".claude", "settings.json");
-  if (!fs12.existsSync(file)) return { file: rel, status: "unchanged" };
+  if (!fs14.existsSync(file)) return { file: rel, status: "unchanged" };
   let settings;
   try {
-    settings = JSON.parse(fs12.readFileSync(file, "utf8"));
+    settings = JSON.parse(fs14.readFileSync(file, "utf8"));
   } catch {
     return { file: rel, status: "skipped", note: "settings.json is not parseable JSON \u2014 left untouched" };
   }
@@ -3689,8 +3821,8 @@ function uninstallClaudeHooks(root2) {
   return { file: rel, status: "written" };
 }
 function writeSettings(file, settings) {
-  fs12.mkdirSync(path43.dirname(file), { recursive: true });
-  fs12.writeFileSync(file, `${JSON.stringify(settings, null, 2)}
+  fs14.mkdirSync(path43.dirname(file), { recursive: true });
+  fs14.writeFileSync(file, `${JSON.stringify(settings, null, 2)}
 `);
 }
 
@@ -3738,7 +3870,7 @@ function registerInstall(program) {
       }
       return;
     }
-    const targets = opts.all ? ASSISTANTS : opts.detect ? detected.map((d) => d.assistant) : tools.map(resolve5);
+    const targets = opts.all ? ASSISTANTS : opts.detect ? detected.map((d) => d.assistant) : tools.map(resolve4);
     if (targets.length === 0) {
       if (opts.detect) {
         if (global.json) json({ root: root2, detected: [], results: [] });
@@ -3775,8 +3907,8 @@ function registerInstall(program) {
   const uninstall = program.command("uninstall").description("remove vg from an AI assistant").argument("<tools...>", "assistant ids").option("--purge", "also delete the skill file").action(function(tools, opts) {
     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 results = tools.map(resolve4).map((a) => ({ id: a.id, removed: uninstallAssistant(a, root2, !!opts.purge) }));
+    if (tools.map(resolve4).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)`);
     }
@@ -3790,7 +3922,7 @@ function registerInstall(program) {
   });
   applyGlobalOptions(uninstall);
 }
-function resolve5(id) {
+function resolve4(id) {
   const a = assistantById(id);
   if (!a) {
     const near = ASSISTANTS.filter(
@@ -3817,15 +3949,15 @@ function stateFile() {
 }
 function readConsent() {
   try {
-    return JSON.parse(fs12.readFileSync(stateFile(), "utf8"));
+    return JSON.parse(fs14.readFileSync(stateFile(), "utf8"));
   } catch {
     return {};
   }
 }
 function writeConsent(state) {
   try {
-    fs12.mkdirSync(path43.dirname(stateFile()), { recursive: true });
-    fs12.writeFileSync(stateFile(), JSON.stringify(state));
+    fs14.mkdirSync(path43.dirname(stateFile()), { recursive: true });
+    fs14.writeFileSync(stateFile(), JSON.stringify(state));
   } catch {
   }
 }
@@ -3835,8 +3967,8 @@ function kernelDisabled() {
 }
 function moduleInstalledAt(dir) {
   try {
-    const meta = JSON.parse(fs12.readFileSync(path43.join(dir, ".module.json"), "utf8"));
-    if (fs12.existsSync(path43.join(dir, "index.js"))) {
+    const meta = JSON.parse(fs14.readFileSync(path43.join(dir, ".module.json"), "utf8"));
+    if (fs14.existsSync(path43.join(dir, "index.js"))) {
       return { installed: true, version: meta.version };
     }
   } catch {
@@ -3910,8 +4042,8 @@ async function installModule(mod, opts = {}) {
     verifyIntegrity(gz, dist.integrity, dist.shasum);
     const entries = untar(zlib.gunzipSync(gz));
     const dir = mod.dir();
-    fs12.rmSync(dir, { recursive: true, force: true });
-    fs12.mkdirSync(dir, { recursive: true });
+    fs14.rmSync(dir, { recursive: true, force: true });
+    fs14.mkdirSync(dir, { recursive: true });
     let wrote = 0;
     for (const e of entries) {
       let rel = null;
@@ -3920,15 +4052,15 @@ async function installModule(mod, opts = {}) {
       if (!rel) continue;
       const target = path43.join(dir, rel);
       if (!target.startsWith(dir + path43.sep) && target !== dir) throw new Error(`unsafe extract path: ${rel}`);
-      fs12.mkdirSync(path43.dirname(target), { recursive: true });
-      fs12.writeFileSync(target, e.body);
+      fs14.mkdirSync(path43.dirname(target), { recursive: true });
+      fs14.writeFileSync(target, e.body);
       wrote += 1;
     }
-    if (!wrote || !fs12.existsSync(path43.join(dir, "index.js"))) {
-      fs12.rmSync(dir, { recursive: true, force: true });
+    if (!wrote || !fs14.existsSync(path43.join(dir, "index.js"))) {
+      fs14.rmSync(dir, { recursive: true, force: true });
       return { status: "unavailable", detail: "package layout not recognized (no dist/index.js)" };
     }
-    fs12.writeFileSync(path43.join(dir, ".module.json"), JSON.stringify({ name: mod.npmName, version }));
+    fs14.writeFileSync(path43.join(dir, ".module.json"), JSON.stringify({ name: mod.npmName, version }));
     mod.onChanged?.();
     return { status: "installed", version };
   } catch (e) {
@@ -3936,7 +4068,7 @@ async function installModule(mod, opts = {}) {
   }
 }
 function removeModule(mod) {
-  fs12.rmSync(mod.dir(), { recursive: true, force: true });
+  fs14.rmSync(mod.dir(), { recursive: true, force: true });
   mod.onChanged?.();
 }
 
@@ -3981,7 +4113,7 @@ function candidatePaths() {
   if (custom) {
     const p = path43.resolve(custom);
     try {
-      if (fs12.statSync(p).isDirectory()) return [path43.join(p, "index.js")];
+      if (fs14.statSync(p).isDirectory()) return [path43.join(p, "index.js")];
     } catch {
     }
     return [p];
@@ -3997,7 +4129,7 @@ async function loadHcsEngine() {
   cached = null;
   if (disabled()) return cached;
   for (const p of candidatePaths()) {
-    if (!fs12.existsSync(p)) continue;
+    if (!fs14.existsSync(p)) continue;
     try {
       const mod = await import(pathToFileURL(p).href);
       const engine = await mod.createHcsEngine?.();
@@ -4136,11 +4268,11 @@ function requireModule(name) {
   return mod;
 }
 function confirm(question) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve21) => {
     const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
     rl.question(question, (answer) => {
       rl.close();
-      resolve23(answer.trim() === "" || /^y(es)?$/i.test(answer.trim()));
+      resolve21(answer.trim() === "" || /^y(es)?$/i.test(answer.trim()));
     });
   });
 }
@@ -4164,7 +4296,7 @@ function hookContext(payloadText, root2, graphOverride) {
   let graph;
   try {
     const preferred = loadGraphPreferIndex(root2, graphPath);
-    graph = preferred ? preferred.graph : parseGraph(fs12.readFileSync(graphPath, "utf8"));
+    graph = preferred ? preferred.graph : parseGraph(fs14.readFileSync(graphPath, "utf8"));
   } catch {
     return null;
   }
@@ -4186,7 +4318,7 @@ function registerHook(program) {
     const global = readGlobal(this);
     const root2 = rootOf(global);
     try {
-      const stdin = fs12.readFileSync(0, "utf8");
+      const stdin = fs14.readFileSync(0, "utf8");
       const context = hookContext(stdin, root2, global.graph);
       if (context) {
         process.stdout.write(
@@ -4207,7 +4339,7 @@ function registerShare(program) {
     const global = readGlobal(this);
     const root2 = rootOf(global);
     const gitDir = path43.join(root2, ".git");
-    if (!fs12.existsSync(gitDir)) {
+    if (!fs14.existsSync(gitDir)) {
       throw new CliError("not a git repository \u2014 run `vg share` inside a git repo", ExitCode.USAGE_ERROR);
     }
     if (opts.undo) {
@@ -4229,22 +4361,22 @@ function registerShare(program) {
 }
 function writeVibgrateGitignore(root2, reports) {
   const dir = path43.join(root2, ".vibgrate");
-  fs12.mkdirSync(dir, { recursive: true });
+  fs14.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");
-  fs12.writeFileSync(path43.join(dir, ".gitignore"), `${lines.join("\n")}
+  fs14.writeFileSync(path43.join(dir, ".gitignore"), `${lines.join("\n")}
 `);
 }
 function writeGitAttributes(root2) {
   const file = path43.join(root2, ".gitattributes");
   const line = ".vibgrate/graph.json merge=vg";
-  let content = fs12.existsSync(file) ? fs12.readFileSync(file, "utf8") : "";
+  let content = fs14.existsSync(file) ? fs14.readFileSync(file, "utf8") : "";
   if (!content.split("\n").some((l) => l.trim() === line)) {
     content = content.length ? `${content.replace(/\s*$/, "")}
 ${line}
 ` : `${line}
 `;
-    fs12.writeFileSync(file, content);
+    fs14.writeFileSync(file, content);
   }
 }
 function configureMergeDriver(root2) {
@@ -4253,7 +4385,7 @@ function configureMergeDriver(root2) {
 }
 function installPreCommitHook(root2) {
   const hooksDir = hookDir(root2);
-  fs12.mkdirSync(hooksDir, { recursive: true });
+  fs14.mkdirSync(hooksDir, { recursive: true });
   const file = path43.join(hooksDir, "pre-commit");
   const block = [
     HOOK_BEGIN,
@@ -4263,7 +4395,7 @@ function installPreCommitHook(root2) {
     "fi",
     HOOK_END
   ].join("\n");
-  let content = fs12.existsSync(file) ? fs12.readFileSync(file, "utf8") : "#!/bin/sh\n";
+  let content = fs14.existsSync(file) ? fs14.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*$/, "")}
@@ -4272,21 +4404,21 @@ ${block}
 `;
   if (!content.startsWith("#!")) content = `#!/bin/sh
 ${content}`;
-  fs12.writeFileSync(file, content);
-  fs12.chmodSync(file, 493);
+  fs14.writeFileSync(file, content);
+  fs14.chmodSync(file, 493);
 }
 function undo(root2) {
   const hookFile = path43.join(hookDir(root2), "pre-commit");
-  if (fs12.existsSync(hookFile)) {
+  if (fs14.existsSync(hookFile)) {
     const re = new RegExp(`\\n*${escapeRe(HOOK_BEGIN)}[\\s\\S]*?${escapeRe(HOOK_END)}\\n*`);
-    const next2 = fs12.readFileSync(hookFile, "utf8").replace(re, "\n");
-    if (next2.trim() === "#!/bin/sh") fs12.rmSync(hookFile);
-    else fs12.writeFileSync(hookFile, next2);
+    const next2 = fs14.readFileSync(hookFile, "utf8").replace(re, "\n");
+    if (next2.trim() === "#!/bin/sh") fs14.rmSync(hookFile);
+    else fs14.writeFileSync(hookFile, next2);
   }
   const attr = path43.join(root2, ".gitattributes");
-  if (fs12.existsSync(attr)) {
-    const next2 = fs12.readFileSync(attr, "utf8").split("\n").filter((l) => l.trim() !== ".vibgrate/graph.json merge=vg").join("\n");
-    fs12.writeFileSync(attr, next2);
+  if (fs14.existsSync(attr)) {
+    const next2 = fs14.readFileSync(attr, "utf8").split("\n").filter((l) => l.trim() !== ".vibgrate/graph.json merge=vg").join("\n");
+    fs14.writeFileSync(attr, next2);
   }
   try {
     git(root2, ["config", "--remove-section", "merge.vg"]);
@@ -4315,7 +4447,7 @@ function registerWatch(program) {
     const debounceMs = Math.max(50, Number(opts.debounce) || DEFAULT_DEBOUNCE_MS);
     const watchRoots = (paths.length ? paths : ["."]).map((p) => path43.resolve(root2, p));
     for (const w of watchRoots) {
-      if (!fs12.existsSync(w)) {
+      if (!fs14.existsSync(w)) {
         throw new CliError(`watch path not found: ${w}`, ExitCode.USAGE_ERROR);
       }
     }
@@ -4368,7 +4500,7 @@ function registerWatch(program) {
     const watchers = [];
     for (const w of watchRoots) {
       try {
-        const watcher = fs12.watch(w, { recursive: true }, (_event, filename) => {
+        const watcher = fs14.watch(w, { recursive: true }, (_event, filename) => {
           if (!filename) {
             schedule("change");
             return;
@@ -4382,11 +4514,11 @@ function registerWatch(program) {
       }
     }
     info(c.dim(`vg watch \xB7 watching ${watchRoots.map((p) => path43.relative(root2, p) || ".").join(", ")} (debounce ${debounceMs}ms) \xB7 Ctrl+C to stop`));
-    await new Promise((resolve23) => {
+    await new Promise((resolve21) => {
       const stop = () => {
         for (const w of watchers) w.close();
         if (timer) clearTimeout(timer);
-        resolve23();
+        resolve21();
       };
       process.once("SIGINT", stop);
       process.once("SIGTERM", stop);
@@ -4717,7 +4849,7 @@ function loadStandards(root2) {
     const p = path43__default.join(root2, rel);
     let text;
     try {
-      text = fs12__default.readFileSync(p, "utf8");
+      text = fs14__default.readFileSync(p, "utf8");
     } catch {
       continue;
     }
@@ -6379,7 +6511,7 @@ function registerModels(program) {
     );
   });
   applyGlobalOptions(modeCmd);
-  const resolve23 = cmd.command("resolve").description("resolve a Code Mode to pack + underlying model + fit (no download)").argument("[mode]", "spark | flow | forge (default: auto-fit or configured default)").action(function(modeArg) {
+  const resolve21 = cmd.command("resolve").description("resolve a Code Mode to pack + underlying model + fit (no download)").argument("[mode]", "spark | flow | forge (default: auto-fit or configured default)").action(function(modeArg) {
     const global = readGlobal(this);
     const root2 = rootOf(global);
     const sys = gatherSystemMemory();
@@ -6411,7 +6543,7 @@ function registerModels(program) {
       info(c.yellow("  will not fit \u2014 choose a lower mode or free memory before loading"));
     }
   });
-  applyGlobalOptions(resolve23);
+  applyGlobalOptions(resolve21);
   const installCmd = cmd.command("install").description("resolve the best Code Mode for this machine and install the pack").argument("[mode]", "spark | flow | forge (default: auto-fit)").option("--dry-run", "print the install plan only \u2014 do not download").option("--yes", "skip prompts (install already runs by default)").action(async function(modeArg, opts) {
     const global = readGlobal(this);
     const root2 = rootOf(global);
@@ -6648,7 +6780,7 @@ function registerModels(program) {
         );
       }
     } else {
-      if (!target.path || !fs12.existsSync(target.path)) {
+      if (!target.path || !fs14.existsSync(target.path)) {
         throw new CliError(
           `model file not found at ${target.path || "(unknown path)"} \u2014 it may already be removed.`,
           ExitCode.NOT_FOUND
@@ -6662,7 +6794,7 @@ function registerModels(program) {
       }
       if (!global.json) info(c.dim(`  $ rm ${target.path}`));
       try {
-        fs12.unlinkSync(target.path);
+        fs14.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);
@@ -6801,8 +6933,8 @@ function registerModels(program) {
     });
     if (opts.out) {
       const outPath = path43.resolve(opts.out);
-      fs12.mkdirSync(path43.dirname(outPath), { recursive: true });
-      fs12.writeFileSync(outPath, `${JSON.stringify(report, null, 2)}
+      fs14.mkdirSync(path43.dirname(outPath), { recursive: true });
+      fs14.writeFileSync(outPath, `${JSON.stringify(report, null, 2)}
 `);
       if (!global.json) info(c.dim(`  wrote ${outPath}`));
     }
@@ -6916,11 +7048,11 @@ function fitColor(label) {
   return label;
 }
 function confirmYesNo(question) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve21) => {
     const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
     rl.question(`${question} [y/N] `, (answer) => {
       rl.close();
-      resolve23(/^y(es)?$/i.test(answer.trim()));
+      resolve21(/^y(es)?$/i.test(answer.trim()));
     });
   });
 }
@@ -7000,7 +7132,7 @@ function codeConfigPath(root2) {
 }
 function loadCodeConfig(root2) {
   try {
-    const raw = JSON.parse(fs12.readFileSync(codeConfigPath(root2), "utf8"));
+    const raw = JSON.parse(fs14.readFileSync(codeConfigPath(root2), "utf8"));
     return sanitize(raw);
   } catch {
     return {};
@@ -7067,7 +7199,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(fs12.readFileSync(file, "utf8"));
+    const raw = JSON.parse(fs14.readFileSync(file, "utf8"));
     const map = raw.mcpServers ?? raw.servers;
     return map && typeof map === "object" ? parseMcpServers(map) : {};
   } catch {
@@ -7192,10 +7324,10 @@ function registerCode(program) {
           return;
         }
         const patchFile = pathMod.join(
-          fs12.mkdtempSync(pathMod.join(os7.tmpdir(), "vg-wt-")),
+          fs14.mkdtempSync(pathMod.join(os7.tmpdir(), "vg-wt-")),
           "delta.patch"
         );
-        fs12.writeFileSync(patchFile, diff2.patch);
+        fs14.writeFileSync(patchFile, diff2.patch);
         const outcome = wt.applyWorktreePatch(gitRunner, root3, patchFile, diff2.files);
         emitLine({ event: "worktree-applied", id: target.id, ...outcome });
         if (!opts.streamJson && !global.json) {
@@ -7260,8 +7392,8 @@ function registerCode(program) {
     if (!customSelection && (modeFlag || !provider && !model)) {
       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-64RK5O6C.js');
+        const { gatherSystemMemory: gatherSystemMemory2 } = await import('./local-runtime-6SNWKSA7.js');
+        const { loadGraph: loadGraph2 } = await import('./load-OR2XVGAV.js');
         const state = readOrchestratorState2();
         const mode = parseMode2(modeFlag) ?? state.defaultMode ?? void 0;
         const pin = mode ? activePin2(mode, state) : null;
@@ -7346,7 +7478,7 @@ function registerCode(program) {
       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-EW2VJ3BZ.js');
+      const { runInteractive } = await import('./interactive-FXPAZAUJ.js');
       await runInteractive(
         rootOf(global),
         global,
@@ -7376,7 +7508,7 @@ function registerCode(program) {
     }
     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-HQ7A5NDL.js');
+      const { ensureCodeMap } = await import('./ensure-map-5C6KG66X.js');
       const mapRoot = rootOf(global);
       try {
         await ensureCodeMap(mapRoot, global, {
@@ -7413,7 +7545,7 @@ function registerCode(program) {
     let mockReply;
     if (opts.mock) {
       try {
-        mockReply = fs12.readFileSync(opts.mock, "utf8");
+        mockReply = fs14.readFileSync(opts.mock, "utf8");
       } catch {
         throw new CliError(`couldn't read the --mock file: ${opts.mock}`, ExitCode.USAGE_ERROR);
       }
@@ -7432,7 +7564,7 @@ function registerCode(program) {
       {}
     );
     if (!opts.mock && route.providers[0]) {
-      const { ensureManagerRuntime } = await import('./model-manager-GJ2YSTSK.js');
+      const { ensureManagerRuntime } = await import('./model-manager-SXHZ5VD4.js');
       const ensure = await ensureManagerRuntime({
         providerId: route.providers[0].id,
         model: route.providers[0].model,
@@ -7461,20 +7593,20 @@ function registerCode(program) {
         process.stdout.write(JSON.stringify(line) + "\n");
       };
       try {
-        const { RunOutcomeRecorder, newOneShotRunId, turnRunId } = await import('./run-outcome-6QNQIHPV.js');
+        const { RunOutcomeRecorder, newOneShotRunId, turnRunId } = await import('./run-outcome-M4546HLJ.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-GY5N7WZT.js');
-        const { nodeCodeFs } = await import('./session-4BGYASOH.js');
+        const { runCodeStreamJson, parseHostMessage } = await import('./stream-json-4DL65D6U.js');
+        const { nodeCodeFs } = await import('./session-HCFJUSKN.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-RJHH3KMF.js');
-        const { resolveGraphBackend } = await import('./graph-backend-W2TNTMY7.js');
+        const { startCodeRuntimeSession } = await import('./runtime-session-6KKMFS6Q.js');
+        const { resolveGraphBackend } = await import('./graph-backend-HH5IIQ55.js');
         const { detectGitRef } = await import('./git-ref-RSRAN4OH.js');
         const { repositoryIdFromRoot } = await import('./paths-62AKTFSR.js');
-        const { vgdRequest: vgdRequest2 } = await import('./vgd-ORPA5C2K.js');
+        const { vgdRequest } = await import('./vgd-QR26FAZD.js');
         const federation = loadOrDiscoverFederation(root2);
         const modelProfile = mergeModelExecutionProfile(
           resolveModelExecutionProfile({
@@ -7505,7 +7637,7 @@ function registerCode(program) {
         };
         if (runtime.socketPath && git2.ref) {
           try {
-            await vgdRequest2(
+            await vgdRequest(
               { op: "put-graph", repositoryId, gitRef: git2.ref, graph },
               { socketPath: runtime.socketPath }
             );
@@ -7532,7 +7664,7 @@ ${res.stderr}` : ""),
             exitCode: res.status ?? 1
           };
         };
-        const { createVgBuiltinMcpTools, mergeExternalToolsets } = await import('./vg-mcp-bridge-IGHJKKSL.js');
+        const { createVgBuiltinMcpTools, mergeExternalToolsets } = await import('./vg-mcp-bridge-FZGX6DYO.js');
         const vgBuiltin = createVgBuiltinMcpTools({
           getGraph: () => graph,
           root: root2,
@@ -7556,7 +7688,7 @@ ${res.stderr}` : ""),
         const os7 = await import('os');
         const pathMod = await import('path');
         const checkpointIndex = pathMod.join(
-          fs12.mkdtempSync(pathMod.join(os7.tmpdir(), "vg-code-cp-")),
+          fs14.mkdtempSync(pathMod.join(os7.tmpdir(), "vg-code-cp-")),
           "index"
         );
         const gitRunner = (gitArgs, gitEnv) => {
@@ -7577,7 +7709,7 @@ ${res.stderr}` : ""),
           files,
           indexFile: checkpointIndex
         });
-        const { loadApprovalRules, addApprovalRule, ruleForAction, ruleLabel } = await import('./approvals-T2KXPJLV.js');
+        const { loadApprovalRules, addApprovalRule, ruleForAction, ruleLabel } = await import('./approvals-IPMUDEDV.js');
         const { loadProjectRules, nodeRulesReader } = await import('./rules-ASYEUNB5.js');
         const projectRules = loadProjectRules(nodeRulesReader(root2));
         if (projectRules.sources.length && !global.quiet) {
@@ -7635,8 +7767,8 @@ ${res.stderr}` : ""),
         };
         try {
           if (opts.session) {
-            const { runCodeStreamJsonSession, STREAM_JSON_PROTOCOL_VERSION } = await import('./stream-json-GY5N7WZT.js');
-            const { runAgent: runAgent2 } = await import('./agent-5ANHRYEI.js');
+            const { runCodeStreamJsonSession, STREAM_JSON_PROTOCOL_VERSION } = await import('./stream-json-4DL65D6U.js');
+            const { runAgent: runAgent2 } = await import('./agent-CUYQKC6S.js');
             const {
               condenseSession,
               loadLatestSession,
@@ -7647,7 +7779,7 @@ ${res.stderr}` : ""),
               sessionsDir,
               summarizeSession
             } = await import('./session-store-AQUORKWB.js');
-            const { VERSION: VERSION2 } = await import('./version-DPAMQW6M.js');
+            const { VERSION: VERSION2 } = await import('./version-UPIC3F4P.js');
             const resumedRecord = typeof opts.continue === "string" ? loadSession(mainRoot, opts.continue) : opts.continue ? loadLatestSession(mainRoot) : void 0;
             if (typeof opts.continue === "string" && !resumedRecord) {
               emitStream({
@@ -7679,8 +7811,8 @@ ${res.stderr}` : ""),
               if (ended) return Promise.resolve(null);
               const queued = pendingTurns.shift();
               if (queued !== void 0) return Promise.resolve(queued);
-              return new Promise((resolve23) => {
-                wakeTurn = resolve23;
+              return new Promise((resolve21) => {
+                wakeTurn = resolve21;
               });
             };
             let turnIndex = 0;
@@ -7859,8 +7991,8 @@ ${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-EW2VJ3BZ.js');
-      const { nodeCodeFs } = await import('./session-4BGYASOH.js');
+      const { agentTask } = await import('./interactive-FXPAZAUJ.js');
+      const { nodeCodeFs } = await import('./session-HCFJUSKN.js');
       const { TtyPrompter } = await import('./ui-K7D3BCHD.js');
       let priorSummary;
       let priorInstruction;
@@ -7875,7 +8007,7 @@ ${res.stderr}` : ""),
         }
       }
       const prompter = tty ? new TtyPrompter() : void 0;
-      const { createVgBuiltinMcpTools, mergeExternalToolsets } = await import('./vg-mcp-bridge-IGHJKKSL.js');
+      const { createVgBuiltinMcpTools, mergeExternalToolsets } = await import('./vg-mcp-bridge-FZGX6DYO.js');
       const vgBuiltin = createVgBuiltinMcpTools({
         getGraph: () => graph,
         root: root2,
@@ -7899,11 +8031,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-RJHH3KMF.js');
-        const { resolveGraphBackend } = await import('./graph-backend-W2TNTMY7.js');
+        const { startCodeRuntimeSession } = await import('./runtime-session-6KKMFS6Q.js');
+        const { resolveGraphBackend } = await import('./graph-backend-HH5IIQ55.js');
         const { detectGitRef } = await import('./git-ref-RSRAN4OH.js');
         const { repositoryIdFromRoot } = await import('./paths-62AKTFSR.js');
-        const { vgdRequest: vgdRequest2 } = await import('./vgd-ORPA5C2K.js');
+        const { vgdRequest } = await import('./vgd-QR26FAZD.js');
         const federation = loadFederation(root2);
         const modelProfile = mergeModelExecutionProfile(
           resolveModelExecutionProfile({
@@ -7923,7 +8055,7 @@ ${res.stderr}` : ""),
         const repositoryId = repositoryIdFromRoot(root2);
         if (runtime.socketPath && git2.ref) {
           try {
-            await vgdRequest2(
+            await vgdRequest(
               { op: "put-graph", repositoryId, gitRef: git2.ref, graph },
               { socketPath: runtime.socketPath }
             );
@@ -7997,7 +8129,7 @@ ${res.stderr}` : ""),
       attribution: { client: "vg-code", provider: providerSlug, model: primary?.model }
     });
     if (opts.out) {
-      fs12.writeFileSync(opts.out, JSON.stringify(result, null, 2) + "\n");
+      fs14.writeFileSync(opts.out, JSON.stringify(result, null, 2) + "\n");
     }
     if (global.json) {
       json(result);
@@ -8049,11 +8181,11 @@ function resolveSecurityTierFlag(flag, fromConfig, auto) {
   return auto ? "L1" : "L0";
 }
 function confirm2(question) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve21) => {
     const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
     rl.question(`${question} [y/N] `, (answer) => {
       rl.close();
-      resolve23(/^y(es)?$/i.test(answer.trim()));
+      resolve21(/^y(es)?$/i.test(answer.trim()));
     });
   });
 }
@@ -8210,7 +8342,7 @@ async function addCmd(root2, rest, opts, asJson) {
 }
 function readPackageVersion(root2) {
   try {
-    const pkg = JSON.parse(fs12__default.readFileSync(path43__default.join(root2, "package.json"), "utf8"));
+    const pkg = JSON.parse(fs14__default.readFileSync(path43__default.join(root2, "package.json"), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : void 0;
   } catch {
     return void 0;
@@ -8218,7 +8350,7 @@ function readPackageVersion(root2) {
 }
 function readOptionalFile(p) {
   try {
-    const t = fs12__default.readFileSync(p, "utf8");
+    const t = fs14__default.readFileSync(p, "utf8");
     return t.trim() ? t : void 0;
   } catch {
     return void 0;
@@ -8366,8 +8498,8 @@ function registerExport(program) {
       out(content.trimEnd());
       return;
     }
-    fs12.mkdirSync(path43.dirname(path43.resolve(file)), { recursive: true });
-    fs12.writeFileSync(file, content);
+    fs14.mkdirSync(path43.dirname(path43.resolve(file)), { recursive: true });
+    fs14.writeFileSync(file, content);
     info(`${c.green("\u2714")} wrote ${file} ${c.dim(`(${format})`)}`);
   });
   applyGlobalOptions(cmd);
@@ -8390,30 +8522,36 @@ function registerBundle(program) {
     } catch {
       throw new CliError("no grammars found to bundle (run a build first)", ExitCode.ERROR);
     }
-    fs12.mkdirSync(path43.join(outDir, "grammars"), { recursive: true });
+    fs14.mkdirSync(path43.join(outDir, "grammars"), { recursive: true });
     let grammarCount = 0;
     for (const { fileName, absPath } of grammarFiles) {
-      fs12.copyFileSync(absPath, path43.join(outDir, "grammars", fileName));
+      fs14.copyFileSync(absPath, path43.join(outDir, "grammars", fileName));
+      grammarCount++;
+    }
+    for (const id of Object.keys(TOOLCHAIN_GRAMMARS).sort()) {
+      const absPath = resolveToolchainGrammar(id);
+      if (!absPath) continue;
+      fs14.copyFileSync(absPath, path43.join(outDir, "grammars", path43.basename(absPath)));
       grammarCount++;
     }
     const included = [`grammars/ (${grammarCount} .wasm)`];
     const graphSrc = resolveGraphPath(root2, global.graph);
-    if (fs12.existsSync(graphSrc)) {
-      fs12.copyFileSync(graphSrc, path43.join(outDir, "graph.json"));
+    if (fs14.existsSync(graphSrc)) {
+      fs14.copyFileSync(graphSrc, path43.join(outDir, "graph.json"));
       included.push("graph.json");
     } else {
       const graph = loadGraphFileWithSnapshot(graphSrc);
       if (graph) {
-        fs12.writeFileSync(path43.join(outDir, "graph.json"), serializeGraph(graph));
+        fs14.writeFileSync(path43.join(outDir, "graph.json"), serializeGraph(graph));
         included.push("graph.json");
       }
     }
     const cat = catalogPath(root2);
-    if (fs12.existsSync(cat)) {
-      fs12.copyFileSync(cat, path43.join(outDir, "vibgrate.lib.json"));
+    if (fs14.existsSync(cat)) {
+      fs14.copyFileSync(cat, path43.join(outDir, "vibgrate.lib.json"));
       included.push("vibgrate.lib.json");
-      if (fs12.existsSync(libDir(root2))) {
-        fs12.cpSync(libDir(root2), path43.join(outDir, "lib"), { recursive: true });
+      if (fs14.existsSync(libDir(root2))) {
+        fs14.cpSync(libDir(root2), path43.join(outDir, "lib"), { recursive: true });
         included.push("lib/");
       }
     }
@@ -8425,7 +8563,7 @@ function registerBundle(program) {
       included,
       usage: "Run `vg build --grammars <this dir>/grammars` to build fully offline."
     };
-    fs12.writeFileSync(path43.join(outDir, "MANIFEST.json"), `${stableStringify(manifest, 2)}
+    fs14.writeFileSync(path43.join(outDir, "MANIFEST.json"), `${stableStringify(manifest, 2)}
 `);
     if (global.json) {
       json({ out: path43.relative(root2, outDir), ...manifest });
@@ -8451,7 +8589,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) => fs12.existsSync(path43.join(root2, f))) ?? null;
+  const configFile = CONFIG_BASENAMES.find((f) => fs14.existsSync(path43.join(root2, f))) ?? null;
   const graph = loadGraph(root2, graphPath);
   let staleFiles = null;
   if (graph) {
@@ -8484,7 +8622,7 @@ async function runDoctor(global) {
     },
     libCatalog: {
       path: path43.relative(root2, catalogPath(root2)),
-      present: fs12.existsSync(catalogPath(root2)),
+      present: fs14.existsSync(catalogPath(root2)),
       libraries: libCount
     },
     credentials: creds,
@@ -8589,445 +8727,6 @@ async function probeReachable(base) {
     clearTimeout(timer);
   }
 }
-function registerDaemon(program) {
-  const cmd = program.command("daemon").description("local Fusion Runtime daemon (vgd) \u2014 workspace registry prototype").option("--socket <path>", "override the daemon socket path");
-  const status = cmd.command("status").description("show whether vgd is running and how many workspaces it tracks").action(async function() {
-    const global = readGlobal(this);
-    const socketPath = socketOf(this);
-    const running = await vgdIsRunning({ socketPath });
-    if (!running) {
-      if (global.json) {
-        json({ running: false, socketPath, version: VGD_PROTOCOL_VERSION });
-      } else {
-        info(c.dim(`vgd \xB7 not running (${socketPath})`));
-      }
-      process.exitCode = ExitCode.NOT_FOUND;
-      return;
-    }
-    const res = await vgdRequest({ op: "status" }, { socketPath });
-    if (!res.ok) throw new CliError(res.error, ExitCode.ERROR);
-    const semantic = await vgdRequest({ op: "embed-status" }, { socketPath }).catch(() => null);
-    const semanticPayload = semantic && semantic.ok && "semantic" in semantic ? semantic.semantic : void 0;
-    if (global.json) json({ running: true, ...res, semantic: semanticPayload });
-    else if ("pid" in res) {
-      const slots = typeof res.graphSlots === "number" ? ` \xB7 ${res.graphSlots} graph slot(s)` : "";
-      info(
-        `vgd \xB7 running pid ${res.pid} \xB7 ${res.workspaces} workspace(s)${slots} \xB7 ${res.uptimeMs}ms up \xB7 ${c.dim(res.socketPath)}`
-      );
-      if (semanticPayload) {
-        const ready = semanticPayload.slots.filter((sl) => sl.state === "ready");
-        const vectors = ready.reduce((n, sl) => n + sl.vectors, 0);
-        const detail = semanticPayload.worker === "unavailable" ? c.dim(semanticPayload.reason ?? "semantic off \u2014 lexical only") : `${ready.length}/${semanticPayload.slots.length} index(es) ready \xB7 ${vectors} vector(s)` + (semanticPayload.model ? ` \xB7 ${semanticPayload.model}` : "");
-        info(`  semantic \xB7 worker ${semanticPayload.worker} \xB7 ${detail}`);
-        for (const sl of semanticPayload.slots) {
-          if (sl.state === "ready") continue;
-          info(c.dim(`    ${sl.repositoryId}@${sl.gitRef} \xB7 ${sl.state}${sl.error ? ` \u2014 ${sl.error}` : ""}`));
-        }
-      }
-    }
-  });
-  applyGlobalOptions(status);
-  const start = cmd.command("start").description("run vgd in the foreground (Ctrl-C to stop)").action(async function() {
-    const global = readGlobal(this);
-    const socketPath = socketOf(this);
-    if (await vgdIsRunning({ socketPath })) {
-      throw new CliError(`vgd is already running at ${socketPath}`, ExitCode.ERROR);
-    }
-    let requestShutdown = () => {
-    };
-    const server = await startVgdServer({
-      socketPath,
-      onShutdownRequest: () => requestShutdown(),
-      // Show the daemon working: graph publishes, branch switches, new repos,
-      // and every semantic index build. Silent under --quiet/--json.
-      log: global.quiet || global.json ? void 0 : (message) => info(c.dim(`vgd \xB7 ${message}`))
-    });
-    if (!global.quiet) {
-      info(`vgd \xB7 listening on ${c.dim(server.socketPath)} (${VGD_PROTOCOL_VERSION})`);
-      info(c.dim("  register a workspace: vg daemon register"));
-      info(c.dim("  status: vg daemon status"));
-    }
-    const shutdown = async () => {
-      await server.close();
-      if (!global.quiet) info(c.dim("vgd \xB7 stopped"));
-      process.exit(0);
-    };
-    requestShutdown = () => void shutdown();
-    process.on("SIGINT", () => void shutdown());
-    process.on("SIGTERM", () => void shutdown());
-    await new Promise(() => {
-    });
-  });
-  applyGlobalOptions(start);
-  const ensure = cmd.command("ensure").description("ensure vgd is running (start in background if needed)").action(async function() {
-    const global = readGlobal(this);
-    const socketPath = socketOf(this);
-    if (await vgdIsRunning({ socketPath })) {
-      const res2 = await vgdRequest({ op: "status" }, { socketPath });
-      if (global.json) {
-        json({ running: true, ensured: false, ...res2.ok ? res2 : { socketPath } });
-      } else if (!global.quiet) {
-        const pid = res2.ok && "pid" in res2 ? res2.pid : "?";
-        info(`vgd \xB7 already running pid ${pid} \xB7 ${c.dim(socketPath)}`);
-      }
-      return;
-    }
-    const child = await startDetachedVgd(socketPath);
-    const res = await vgdRequest({ op: "status" }, { socketPath });
-    if (!res.ok) {
-      throw new CliError(
-        `vgd started (pid ${child ?? "?"}) but status failed: ${res.error} (${socketPath})`,
-        ExitCode.ERROR
-      );
-    }
-    if (global.json) {
-      json({ running: true, ensured: true, ...res });
-    } else if (!global.quiet) {
-      const pid = "pid" in res ? res.pid : child;
-      info(`vgd \xB7 started in background pid ${pid} \xB7 ${c.dim(socketPath)}`);
-    }
-  });
-  applyGlobalOptions(ensure);
-  const stop = cmd.command("stop").description("stop the running vgd (idempotent \u2014 succeeds if none is running)").action(async function() {
-    const global = readGlobal(this);
-    const socketPath = socketOf(this);
-    const result = await stopVgd(socketPath);
-    if (global.json) {
-      json({ stopped: result === "stopped", result, socketPath });
-    } else if (!global.quiet) {
-      if (result === "stopped") info(`vgd \xB7 stopped ${c.dim(socketPath)}`);
-      else if (result === "not-running") info(c.dim(`vgd \xB7 not running (${socketPath})`));
-    }
-    if (result === "refused") {
-      throw new CliError(
-        "this vgd is embedded in another process (e.g. vg code) \u2014 stop that process instead",
-        ExitCode.ERROR
-      );
-    }
-    if (result === "failed") {
-      throw new CliError(
-        `vgd did not stop within 5s (${socketPath}) \u2014 check \`vg daemon status\` and stop the process manually`,
-        ExitCode.ERROR
-      );
-    }
-  });
-  applyGlobalOptions(stop);
-  const restart = cmd.command("restart").description("restart vgd (stop if running, then start in the background)").action(async function() {
-    const global = readGlobal(this);
-    const socketPath = socketOf(this);
-    const stopResult = await stopVgd(socketPath);
-    if (stopResult === "refused") {
-      throw new CliError(
-        "this vgd is embedded in another process (e.g. vg code) \u2014 stop that process instead",
-        ExitCode.ERROR
-      );
-    }
-    if (stopResult === "failed") {
-      throw new CliError(
-        `vgd did not stop within 5s (${socketPath}) \u2014 check \`vg daemon status\` and stop the process manually`,
-        ExitCode.ERROR
-      );
-    }
-    await startDetachedVgd(socketPath);
-    const res = await vgdRequest({ op: "status" }, { socketPath });
-    if (global.json) {
-      json({ running: true, restarted: true, ...res.ok ? res : { socketPath } });
-    } else if (!global.quiet) {
-      const pid = res.ok && "pid" in res ? res.pid : "?";
-      info(`vgd \xB7 restarted pid ${pid} \xB7 ${c.dim(socketPath)}`);
-    }
-  });
-  applyGlobalOptions(restart);
-  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 = path43.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);
-    }
-    const res = await vgdRequest({ op: "register", root: root2 }, { socketPath });
-    if (!res.ok) throw new CliError(res.error, ExitCode.ERROR);
-    if (global.json) json(res);
-    else if ("workspace" in res) {
-      info(`vgd \xB7 registered ${res.workspace.root}`);
-      info(c.dim(`  id ${res.workspace.id}`));
-      info(c.dim(`  graph ${res.workspace.graphPath}`));
-    }
-  });
-  applyGlobalOptions(register);
-  const list = cmd.command("list").description("list workspaces registered with the running vgd").action(async function() {
-    const global = readGlobal(this);
-    const socketPath = socketOf(this);
-    if (!await vgdIsRunning({ socketPath })) {
-      throw new CliError(`vgd is not running (${socketPath})`, ExitCode.NOT_FOUND);
-    }
-    const res = await vgdRequest({ op: "list" }, { socketPath });
-    if (!res.ok) throw new CliError(res.error, ExitCode.ERROR);
-    if (global.json) json(res);
-    else if ("workspaces" in res && Array.isArray(res.workspaces)) {
-      if (res.workspaces.length === 0) info(c.dim("vgd \xB7 no workspaces registered"));
-      for (const w of res.workspaces) {
-        const tag = w.label ? ` (${w.label}${w.role ? `/${w.role}` : ""})` : "";
-        info(`${w.root}${tag}`);
-        info(c.dim(`  id ${w.id} \xB7 graph ${w.graphPath}`));
-      }
-    }
-  });
-  applyGlobalOptions(list);
-  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 = path43.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);
-    }
-    const { loadFederation } = await import('./federation-MDQPO3PW.js');
-    const fed = loadFederation(primary);
-    if (!fed) throw new CliError(`could not load federation for ${primary}`, ExitCode.ERROR);
-    const res = await vgdRequest(
-      {
-        op: "register-federation",
-        primaryRoot: fed.primaryRoot,
-        members: fed.members.map((m) => ({ root: m.root, label: m.label, role: m.role }))
-      },
-      { socketPath }
-    );
-    if (!res.ok) throw new CliError(res.error, ExitCode.ERROR);
-    if (global.json) json(res);
-    else if ("workspaces" in res && Array.isArray(res.workspaces)) {
-      info(`vgd \xB7 federation registered (${res.workspaces.length} workspace(s))`);
-      for (const w of res.workspaces) {
-        info(c.dim(`  ${w.label ?? w.root}${w.role ? ` [${w.role}]` : ""}`));
-      }
-    }
-  });
-  applyGlobalOptions(federation);
-  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 = path43.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);
-    }
-    const opts = this.opts();
-    const loaded = await vgdRequest(
-      { op: "load-graph", root: root2, gitRef: opts.gitRef?.trim() || void 0, graphPath: global.graph },
-      { socketPath }
-    );
-    let put = loaded;
-    if (!loaded.ok && loaded.code === "no_map") {
-      throw new CliError(loaded.error, ExitCode.NOT_FOUND);
-    }
-    if (!loaded.ok) {
-      const { loadGraph: loadGraph2 } = await import('./load-64RK5O6C.js');
-      const { detectGitRef } = await import('./git-ref-RSRAN4OH.js');
-      const { repositoryIdFromRoot } = await import('./paths-62AKTFSR.js');
-      const graph = loadGraph2(root2, global.graph);
-      if (!graph) {
-        throw new CliError(
-          `no code map found for ${root2} \u2014 run \`vg build\` (or bare \`vg\`) first`,
-          ExitCode.NOT_FOUND
-        );
-      }
-      const reg = await vgdRequest({ op: "register", root: root2 }, { socketPath });
-      if (!reg.ok) throw new CliError(reg.error, ExitCode.ERROR);
-      const git2 = opts.gitRef?.trim() || detectGitRef(root2).ref || "HEAD";
-      const repositoryId = reg.ok && "workspace" in reg ? reg.workspace.id : repositoryIdFromRoot(root2);
-      put = await vgdRequest(
-        { op: "put-graph", repositoryId, gitRef: git2, graph },
-        { socketPath }
-      );
-      if (!put.ok) throw new CliError(put.error, ExitCode.ERROR);
-    }
-    if (global.json) json(put);
-    else if (put.ok && "stored" in put) {
-      info(`vgd \xB7 published graph \xB7 ${put.nodeCount} node(s) \xB7 ref ${put.gitRef}`);
-      info(c.dim(`  repositoryId ${put.repositoryId}`));
-    }
-  });
-  applyGlobalOptions(publish);
-  const query = cmd.command("query").description("query the ActiveGraph held by vgd (lexical/structural)").option("--repository-id <id>", "repository id from `vg daemon list` (default: cwd workspace)").argument("<query...>", "what to find").option("--limit <n>", "max matches", "12").option("--git-ref <ref>", "branch or SHA (default: current slot)").action(async function(queryParts) {
-    const global = readGlobal(this);
-    const socketPath = socketOf(this);
-    const opts = this.opts();
-    const q = (queryParts ?? []).join(" ").trim();
-    if (!q) throw new CliError("say what to find", ExitCode.USAGE_ERROR);
-    if (!await vgdIsRunning({ socketPath })) {
-      throw new CliError(`vgd is not running (${socketPath})`, ExitCode.NOT_FOUND);
-    }
-    const repositoryId = opts.repositoryId?.trim() || await repositoryIdForCwd(socketPath, rootOf(global));
-    const res = await vgdRequest(
-      {
-        op: "query-graph",
-        repositoryId,
-        query: q,
-        limit: opts.limit ? Number(opts.limit) : 12,
-        gitRef: opts.gitRef
-      },
-      { socketPath }
-    );
-    if (!res.ok) throw new CliError(res.error, ExitCode.ERROR);
-    if (global.json) json(res);
-    else if ("matches" in res) {
-      info(`vgd query \xB7 ${res.matches.length} match(es) \xB7 ref ${res.gitRef}`);
-      for (const m of res.matches) {
-        info(`${m.qualifiedName} (${m.kind}) ${m.file}:${m.line}`);
-        info(c.dim(`  score ${m.score} \xB7 ${m.why}`));
-      }
-    }
-  });
-  applyGlobalOptions(query);
-  const impact = cmd.command("impact").description("blast radius for a symbol in the vgd ActiveGraph").option("--repository-id <id>", "repository id (default: cwd workspace)").argument("<symbol>", "symbol id or qualified name").option("--depth <n>", "max dependency depth", "4").option("--git-ref <ref>", "branch or SHA").action(async function(symbol) {
-    const global = readGlobal(this);
-    const socketPath = socketOf(this);
-    const opts = this.opts();
-    if (!await vgdIsRunning({ socketPath })) {
-      throw new CliError(`vgd is not running (${socketPath})`, ExitCode.NOT_FOUND);
-    }
-    const repositoryId = opts.repositoryId?.trim() || await repositoryIdForCwd(socketPath, rootOf(global));
-    const res = await vgdRequest(
-      {
-        op: "impact-of",
-        repositoryId,
-        symbol: symbol.trim(),
-        depth: opts.depth ? Number(opts.depth) : 4,
-        gitRef: opts.gitRef
-      },
-      { socketPath }
-    );
-    if (!res.ok) throw new CliError(res.error, ExitCode.ERROR);
-    if (global.json) json(res);
-    else if ("affected" in res) {
-      info(`vgd impact \xB7 ${res.root.name} \xB7 depth ${res.depth} \xB7 ${res.affected.length} affected`);
-      for (const a of res.affected.slice(0, 30)) {
-        info(`- ${a.name} (${a.file}:${a.line}) d=${a.depth}`);
-      }
-    }
-  });
-  applyGlobalOptions(impact);
-  const graphs = cmd.command("graphs").description("list multi-branch ActiveGraph slots resident in the running vgd (Fusion \xA74.1.1)").option("--repository-id <id>", "filter slots to one repository id").action(async function() {
-    const global = readGlobal(this);
-    const socketPath = socketOf(this);
-    const opts = this.opts();
-    if (!await vgdIsRunning({ socketPath })) {
-      throw new CliError(`vgd is not running (${socketPath})`, ExitCode.NOT_FOUND);
-    }
-    const res = await vgdRequest(
-      { op: "list-graph-slots", repositoryId: opts.repositoryId },
-      { socketPath }
-    );
-    if (!res.ok) throw new CliError(res.error, ExitCode.ERROR);
-    if (global.json) json(res);
-    else if ("slots" in res) {
-      if (!res.slots.length) info(c.dim("vgd \xB7 no graph slots resident"));
-      for (const s of res.slots) {
-        const cur = s.current ? c.green(" current") : "";
-        const idle = s.evictable ? c.yellow(" idle") : "";
-        info(`${s.repositoryId.slice(0, 8)}\u2026  ${s.gitRef}${cur}${idle}`);
-        info(c.dim(`  nodes ${s.nodeCount} \xB7 idle ${Math.round(s.idleMs / 1e3)}s \xB7 loaded ${new Date(s.loadedAt).toISOString()}`));
-      }
-    }
-  });
-  applyGlobalOptions(graphs);
-  applyGlobalOptions(cmd);
-}
-function socketOf(cmd) {
-  let c2 = cmd;
-  while (c2) {
-    const opts = c2.opts();
-    if (opts.socket) return path43.resolve(opts.socket);
-    c2 = c2.parent;
-  }
-  return vgdSocketPath();
-}
-function spawnDetachedDaemonStart(socketPath) {
-  const opts = {
-    detached: true,
-    stdio: "ignore",
-    env: process.env,
-    windowsHide: true
-  };
-  const entry = process.argv[1];
-  if (entry && (entry.endsWith(".js") || entry.endsWith(".mjs") || entry.endsWith(".cjs"))) {
-    return spawn(process.execPath, [entry, "daemon", "start", "--socket", socketPath], opts);
-  }
-  return spawn(process.argv[0] || "vg", ["daemon", "start", "--socket", socketPath], opts);
-}
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-async function startDetachedVgd(socketPath) {
-  const child = spawnDetachedDaemonStart(socketPath);
-  child.unref();
-  const readyMs = 3e4;
-  const deadline = Date.now() + readyMs;
-  while (Date.now() < deadline) {
-    await sleep(150);
-    if (await vgdIsRunning({ socketPath })) return child.pid;
-    if (child.exitCode != null && child.exitCode !== 0) {
-      throw new CliError(
-        `vgd child exited ${child.exitCode} before becoming ready at ${socketPath}`,
-        ExitCode.ERROR
-      );
-    }
-  }
-  throw new CliError(
-    `vgd failed to become ready within ${Math.round(readyMs / 1e3)}s at ${socketPath}`,
-    ExitCode.ERROR
-  );
-}
-async function stopVgd(socketPath) {
-  if (!await vgdIsRunning({ socketPath })) return "not-running";
-  let acknowledged = false;
-  try {
-    const res = await vgdRequest({ op: "shutdown" }, { socketPath });
-    if (res.ok) acknowledged = true;
-    else if (res.code === "shutdown_unsupported") return "refused";
-  } catch {
-  }
-  if (!acknowledged) {
-    const pid = readVgdPid();
-    if (pid == null) return "failed";
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch {
-      return "failed";
-    }
-  }
-  const deadline = Date.now() + 5e3;
-  while (Date.now() < deadline) {
-    await sleep(100);
-    if (!await vgdIsRunning({ socketPath })) return "stopped";
-  }
-  return "failed";
-}
-async function restartVgdIfRunning(socketPath = vgdSocketPath()) {
-  try {
-    const stopResult = await stopVgd(socketPath);
-    if (stopResult === "not-running") return "not-running";
-    if (stopResult === "refused") return "refused";
-    if (stopResult === "failed") return "failed";
-    await startDetachedVgd(socketPath);
-    return "restarted";
-  } catch {
-    return "failed";
-  }
-}
-function readVgdPid() {
-  try {
-    const raw = fs12.readFileSync(vgdPidPath(), "utf8").trim();
-    const pid = Number.parseInt(raw, 10);
-    return Number.isInteger(pid) && pid > 0 ? pid : null;
-  } catch {
-    return null;
-  }
-}
-async function repositoryIdForCwd(socketPath, root2) {
-  const { repositoryIdFromRoot } = await import('./paths-62AKTFSR.js');
-  const reg = await vgdRequest({ op: "register", root: root2 }, { socketPath });
-  if (reg.ok && "workspace" in reg) return reg.workspace.id;
-  return repositoryIdFromRoot(root2);
-}
 function verifyContextPolicyPatch(patch) {
   const { signature, contentHash, ...rest } = patch;
   const expected = hashString(
@@ -9100,7 +8799,7 @@ function registerPolicy(program) {
     const global = readGlobal(this);
     let raw;
     try {
-      raw = fs12.readFileSync(file, "utf8");
+      raw = fs14.readFileSync(file, "utf8");
     } catch {
       throw new CliError(`cannot read ${file}`, ExitCode.NOT_FOUND);
     }
@@ -9288,8 +8987,8 @@ async function readStdin() {
 }
 function readFileOrThrow(file, label) {
   const p = path43.resolve(file);
-  if (!fs12.existsSync(p)) throw usageError(`${label} file not found: ${p}`);
-  return fs12.readFileSync(p, "utf-8");
+  if (!fs14.existsSync(p)) throw usageError(`${label} file not found: ${p}`);
+  return fs14.readFileSync(p, "utf-8");
 }
 async function readInput(file, label) {
   return file ? readFileOrThrow(file, label) : readStdin();
@@ -9301,8 +9000,8 @@ function writeOutput(outFile, content) {
   }
   const outPath = path43.resolve(outFile);
   const dir = path43.dirname(outPath);
-  if (!fs12.existsSync(dir)) throw usageError(`output directory does not exist: ${dir}`);
-  fs12.writeFileSync(outPath, content.endsWith("\n") ? content : content + "\n", "utf-8");
+  if (!fs14.existsSync(dir)) throw usageError(`output directory does not exist: ${dir}`);
+  fs14.writeFileSync(outPath, content.endsWith("\n") ? content : content + "\n", "utf-8");
   info(c.dim(`wrote ${outPath}`));
 }
 function requireChoice(value, valid2, flag) {
@@ -9336,7 +9035,7 @@ function registerHcs(program) {
     const statePath = opts.previous ?? opts.out;
     const useIncremental = canIncremental && statePath !== void 0;
     const root2 = path43.resolve(dir);
-    if (!fs12.existsSync(root2) || !fs12.statSync(root2).isDirectory()) {
+    if (!fs14.existsSync(root2) || !fs14.statSync(root2).isDirectory()) {
       throw usageError(`not a directory: ${root2}`);
     }
     const supported = new Set(
@@ -9354,7 +9053,7 @@ function registerHcs(program) {
     const walk2 = (abs, rel) => {
       let entries;
       try {
-        entries = fs12.readdirSync(abs, { withFileTypes: true });
+        entries = fs14.readdirSync(abs, { withFileTypes: true });
       } catch {
         return;
       }
@@ -9371,8 +9070,8 @@ function registerHcs(program) {
         const lang = extToLang.get(path43.extname(entry.name).toLowerCase());
         if (!lang) continue;
         try {
-          if (fs12.statSync(absChild).size > MAX_EXTRACT_FILE_BYTES) continue;
-          const content = fs12.readFileSync(absChild, "utf-8");
+          if (fs14.statSync(absChild).size > MAX_EXTRACT_FILE_BYTES) continue;
+          const content = fs14.readFileSync(absChild, "utf-8");
           let bucket = byLanguage.get(lang);
           if (!bucket) byLanguage.set(lang, bucket = []);
           bucket.push({ path: relChild, content });
@@ -9403,7 +9102,7 @@ function registerHcs(program) {
       return;
     }
     const previousPath = path43.resolve(statePath);
-    const previousNdjson = !opts.full && fs12.existsSync(previousPath) ? fs12.readFileSync(previousPath, "utf-8") : "";
+    const previousNdjson = !opts.full && fs14.existsSync(previousPath) ? fs14.readFileSync(previousPath, "utf-8") : "";
     if (opts.full) info(c.dim("running a full re-extraction (--full)"));
     else if (!previousNdjson) info(c.dim(`previous stream not found at ${previousPath} \u2014 running a full extraction`));
     const currentFilesJson = JSON.stringify(
@@ -9519,7 +9218,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-WVD6P5IO.js');
+    const { runBaseline } = await import('./baseline-NZFGLMER.js');
     await runBaseline(rootDir);
   }
   console.log("");
@@ -9660,9 +9359,9 @@ function sitesFromImportFiles(files, limit = 10) {
 }
 async function defaultReadFile(absPath) {
   try {
-    const stat2 = await fs27.stat(absPath);
+    const stat2 = await fs28.stat(absPath);
     if (!stat2.isFile() || stat2.size > MAX_FILE_BYTES) return null;
-    return await fs27.readFile(absPath, "utf8");
+    return await fs28.readFile(absPath, "utf8");
   } catch {
     return null;
   }
@@ -10329,7 +10028,7 @@ var SKIP_DIRS3 = /* @__PURE__ */ new Set([
 function scanStaleness(rootDir, artifactPath) {
   let ref;
   try {
-    ref = fs12.statSync(artifactPath).mtimeMs;
+    ref = fs14.statSync(artifactPath).mtimeMs;
   } catch {
     return { stale: false };
   }
@@ -10341,7 +10040,7 @@ function scanStaleness(rootDir, artifactPath) {
     if (depth > 8 || scanned > MAX_ENTRIES2) return;
     let entries;
     try {
-      entries = fs12.readdirSync(dir, { withFileTypes: true });
+      entries = fs14.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -10356,7 +10055,7 @@ function scanStaleness(rootDir, artifactPath) {
       const abs = path43.join(dir, e.name);
       let mtimeMs;
       try {
-        mtimeMs = fs12.statSync(abs).mtimeMs;
+        mtimeMs = fs14.statSync(abs).mtimeMs;
       } catch {
         continue;
       }
@@ -10493,7 +10192,7 @@ function analyzeTree(root2, packages) {
     if (depth > MAX_DEPTH || filesSeen >= MAX_FILES) return;
     let entries;
     try {
-      entries = fs12.readdirSync(dir, { withFileTypes: true });
+      entries = fs14.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -10511,8 +10210,8 @@ function analyzeTree(root2, packages) {
       const full = path43.join(dir, entry.name);
       let content;
       try {
-        if (fs12.statSync(full).size > MAX_FILE_BYTES2) continue;
-        content = fs12.readFileSync(full, "utf8");
+        if (fs14.statSync(full).size > MAX_FILE_BYTES2) continue;
+        content = fs14.readFileSync(full, "utf8");
       } catch {
         continue;
       }
@@ -10880,8 +10579,8 @@ async function fetchLatestVersion() {
 }
 async function writeCache(data) {
   try {
-    await fs27.mkdir(CACHE_DIR, { recursive: true });
-    await fs27.writeFile(CACHE_FILE, JSON.stringify(data), "utf-8");
+    await fs28.mkdir(CACHE_DIR, { recursive: true });
+    await fs28.writeFile(CACHE_FILE, JSON.stringify(data), "utf-8");
   } catch {
   }
 }
@@ -10919,7 +10618,7 @@ function scheduleDeferredUpdate(command, pid = process.pid, dir = os.tmpdir()) {
   const scriptPath = path43.join(dir, `vg-update-${stamp}.cmd`);
   const logPath = path43.join(dir, `vg-update-${stamp}.log`);
   try {
-    fs12.writeFileSync(scriptPath, buildDeferredUpdateScript({ pid, command, logPath }), "utf8");
+    fs14.writeFileSync(scriptPath, buildDeferredUpdateScript({ pid, command, logPath }), "utf8");
     const child = spawn(process.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", scriptPath], {
       detached: true,
       stdio: "ignore",
@@ -10943,7 +10642,7 @@ function detectGlobalInstall(execPath = process.argv[1] || "", cwd = process.cwd
   if (!execPath) return null;
   let resolved = execPath;
   try {
-    resolved = fs12.realpathSync(execPath);
+    resolved = fs14.realpathSync(execPath);
   } catch {
   }
   const p = resolved.replace(/\\/g, "/");
@@ -11049,19 +10748,19 @@ async function confirmWorkspaceRoot(pm) {
 async function confirm3(question) {
   if (!(process.stdin.isTTY && process.stdout.isTTY)) return false;
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve23) => {
+  return new Promise((resolve21) => {
     rl.question(chalk7.yellow(question), (ans) => {
       rl.close();
       const t = ans.trim().toLowerCase();
-      resolve23(t === "y" || t === "yes");
+      resolve21(t === "y" || t === "yes");
     });
   });
 }
 var CAPTURED_OUTPUT_LIMIT = 64e3;
 async function runInstall(cmd, cwd) {
-  const { spawn: spawn5 } = await import('child_process');
-  return new Promise((resolve23) => {
-    const child = spawn5(cmd, {
+  const { spawn: spawn4 } = await import('child_process');
+  return new Promise((resolve21) => {
+    const child = spawn4(cmd, {
       cwd,
       shell: true,
       stdio: ["inherit", "pipe", "pipe"],
@@ -11079,22 +10778,22 @@ async function runInstall(cmd, cwd) {
     };
     tee(child.stdout, process.stdout);
     tee(child.stderr, process.stderr);
-    child.on("error", (err) => resolve23({ ok: false, output: `${output}
+    child.on("error", (err) => resolve21({ ok: false, output: `${output}
 ${String(err)}` }));
-    child.on("close", (code) => resolve23({ ok: code === 0, output }));
+    child.on("close", (code) => resolve21({ ok: code === 0, output }));
   });
 }
 async function releaseWindowsFileLocks(cwd, keepVersion) {
   reapAndReport(cwd, keepVersion);
   try {
-    const { vgdSocketPath: vgdSocketPath2 } = await import('./vgd-ORPA5C2K.js');
-    const result = await stopVgd(vgdSocketPath2());
+    const { vgdSocketPath } = await import('./vgd-QR26FAZD.js');
+    const result = await stopVgd(vgdSocketPath());
     if (result === "stopped") {
       console.log(chalk7.dim("Stopped the vgd daemon so its files can be replaced \u2014 it restarts on the next command."));
     } else if (result === "refused") {
       console.log(
         chalk7.dim(
-          "A vgd embedded in another process (e.g. vg code) is running \u2014 close that session if the update reports a locked file."
+          "A vgd that cannot be stopped remotely is running \u2014 close the process holding the socket if the update reports a locked file."
         )
       );
     }
@@ -11212,12 +10911,12 @@ var updateCommand = new Command("update").description("Update vibgrate to the la
 );
 async function rewarmVgdAndReport(cwd) {
   try {
-    const { vgdIsRunning: vgdIsRunning2, vgdRequest: vgdRequest2 } = await import('./vgd-ORPA5C2K.js');
-    if (!await vgdIsRunning2()) return;
-    const loaded = await vgdRequest2({ op: "load-graph", root: cwd });
+    const { vgdIsRunning, vgdRequest } = await import('./vgd-QR26FAZD.js');
+    if (!await vgdIsRunning()) return;
+    const loaded = await vgdRequest({ op: "load-graph", root: cwd });
     if (!loaded.ok || !("repositoryId" in loaded)) return;
     console.log(chalk7.dim("Re-published the code map into the restarted daemon."));
-    const indexed = await vgdRequest2({ op: "embed-index", repositoryId: loaded.repositoryId });
+    const indexed = await vgdRequest({ op: "embed-index", repositoryId: loaded.repositoryId });
     if (indexed.ok && "vectors" in indexed && indexed.state === "ready") {
       console.log(chalk7.dim(`Semantic index warm again (${indexed.vectors} vectors).`));
     }
@@ -11236,7 +10935,7 @@ async function restartVgdAndReport() {
     console.log(chalk7.dim("Restarted the vgd daemon on the new version."));
   } else if (result === "refused") {
     console.log(
-      chalk7.dim("A vgd embedded in another process (e.g. vg code) is running \u2014 restart that session to pick up the update.")
+      chalk7.dim("A vgd that cannot be stopped remotely is running \u2014 restart the process holding the socket to pick up the update.")
     );
   } else {
     console.log(
@@ -11536,14 +11235,14 @@ function promptPlanSelection(response) {
   const defaultIdx = plans.findIndex((p) => p.tier === response.recommended);
   const def = defaultIdx >= 0 ? defaultIdx + 1 : 1;
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve23) => {
+  return new Promise((resolve21) => {
     rl.question(`Plan [1-${plans.length}, default ${def}, q to cancel]: `, (ans) => {
       rl.close();
       const t = ans.trim().toLowerCase();
-      if (t === "q" || t === "quit") return resolve23(null);
+      if (t === "q" || t === "quit") return resolve21(null);
       const n = t === "" ? def : Number.parseInt(t, 10);
-      if (!Number.isInteger(n) || n < 1 || n > plans.length) return resolve23(null);
-      resolve23(plans[n - 1].tier);
+      if (!Number.isInteger(n) || n < 1 || n > plans.length) return resolve21(null);
+      resolve21(plans[n - 1].tier);
     });
   });
 }
@@ -12385,7 +12084,7 @@ function openUrl(url) {
 }
 
 // src/reporting/commands/login.ts
-var delay = (ms) => new Promise((resolve23) => setTimeout(resolve23, ms));
+var delay = (ms) => new Promise((resolve21) => setTimeout(resolve21, ms));
 function isInside(dir, file) {
   const rel = path43.relative(dir, file);
   return !!rel && !rel.startsWith("..") && !path43.isAbsolute(rel);
@@ -13760,17 +13459,17 @@ function resolveSigningKey(root2, explicit) {
   const chosen = process.env.VG_ATTEST_KEY;
   const keyPath = chosen ? path43.resolve(chosen) : path43.join(root2, ".vibgrate", DEFAULT_KEY);
   let minted = false;
-  if (!fs12.existsSync(keyPath)) {
+  if (!fs14.existsSync(keyPath)) {
     if (chosen) throw new CliError(`signing key not found: ${chosen}`, ExitCode.USAGE_ERROR);
     const kp = generateKeypair();
-    fs12.mkdirSync(path43.dirname(keyPath), { recursive: true });
-    fs12.writeFileSync(keyPath, kp.privatePem, { mode: 384 });
-    fs12.writeFileSync(`${keyPath}.pub`, kp.publicPem);
+    fs14.mkdirSync(path43.dirname(keyPath), { recursive: true });
+    fs14.writeFileSync(keyPath, kp.privatePem, { mode: 384 });
+    fs14.writeFileSync(`${keyPath}.pub`, kp.publicPem);
     minted = true;
   }
   let key2;
   try {
-    key2 = crypto3.createPrivateKey(fs12.readFileSync(keyPath, "utf8"));
+    key2 = crypto3.createPrivateKey(fs14.readFileSync(keyPath, "utf8"));
   } catch {
     throw new CliError(`could not read an Ed25519 private key from ${keyPath}`, ExitCode.USAGE_ERROR);
   }
@@ -13781,8 +13480,8 @@ function resolveSigningKey(root2, explicit) {
 }
 function writeBundle(input) {
   const dir = input.outDir;
-  fs12.mkdirSync(path43.join(dir, "inputs", "releases"), { recursive: true });
-  const write = (rel, data) => fs12.writeFileSync(path43.join(dir, rel), `${JSON.stringify(data, null, 2)}
+  fs14.mkdirSync(path43.join(dir, "inputs", "releases"), { recursive: true });
+  const write = (rel, data) => fs14.writeFileSync(path43.join(dir, rel), `${JSON.stringify(data, null, 2)}
 `);
   write("result.json", input.result);
   write(path43.join("inputs", "advisory.json"), input.advisory);
@@ -13806,13 +13505,13 @@ function writeBundle(input) {
     disclaimer: input.regime.disclaimer
   });
   if (input.envelope) {
-    fs12.writeFileSync(path43.join(dir, "evidence.intoto.jsonl"), `${JSON.stringify(input.envelope)}
+    fs14.writeFileSync(path43.join(dir, "evidence.intoto.jsonl"), `${JSON.stringify(input.envelope)}
 `);
   }
   if (input.timestampToken) {
-    fs12.writeFileSync(path43.join(dir, "timestamp.tsr"), input.timestampToken);
+    fs14.writeFileSync(path43.join(dir, "timestamp.tsr"), input.timestampToken);
   }
-  fs12.writeFileSync(path43.join(dir, "VERIFY.md"), verifyDoc(input));
+  fs14.writeFileSync(path43.join(dir, "VERIFY.md"), verifyDoc(input));
   return dir;
 }
 function verifyDoc(input) {
@@ -14155,7 +13854,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) {
-    fs12.writeFileSync(path43.resolve(rootDir, opts.out), md);
+    fs14.writeFileSync(path43.resolve(rootDir, opts.out), md);
     console.error(chalk7.green("\u2714") + ` pack written to ${opts.out}`);
   } else {
     console.log(md);
@@ -14198,19 +13897,19 @@ 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 = path43.resolve(bundlePath);
-  const envPath = fs12.statSync(abs).isDirectory() ? path43.join(abs, "evidence.intoto.jsonl") : abs;
-  if (!fs12.existsSync(envPath)) throw new CliError(`no evidence.intoto.jsonl at ${bundlePath}`, ExitCode.NOT_FOUND);
-  const envelope = JSON.parse(fs12.readFileSync(envPath, "utf8").trim().split("\n")[0]);
+  const envPath = fs14.statSync(abs).isDirectory() ? path43.join(abs, "evidence.intoto.jsonl") : abs;
+  if (!fs14.existsSync(envPath)) throw new CliError(`no evidence.intoto.jsonl at ${bundlePath}`, ExitCode.NOT_FOUND);
+  const envelope = JSON.parse(fs14.readFileSync(envPath, "utf8").trim().split("\n")[0]);
   const resultPath = path43.join(path43.dirname(envPath), "result.json");
-  const result = fs12.existsSync(resultPath) ? JSON.parse(fs12.readFileSync(resultPath, "utf8")) : void 0;
-  const publicKeyPem = opts.pub ? fs12.readFileSync(path43.resolve(opts.pub), "utf8") : void 0;
+  const result = fs14.existsSync(resultPath) ? JSON.parse(fs14.readFileSync(resultPath, "utf8")) : void 0;
+  const publicKeyPem = opts.pub ? fs14.readFileSync(path43.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 = path43.join(path43.dirname(envPath), "timestamp.tsr");
-  if (fs12.existsSync(tsrPath) && result) {
-    const t = verifyTimestamp(fs12.readFileSync(tsrPath), exposureSubjectDigest(result));
+  if (fs14.existsSync(tsrPath) && result) {
+    const t = verifyTimestamp(fs14.readFileSync(tsrPath), exposureSubjectDigest(result));
     const tcolor = t.imprintMatches ? chalk7.green : chalk7.red;
     console.log("  " + tcolor("TIMESTAMP") + `  ${t.reason}`);
   }
@@ -14309,9 +14008,9 @@ var pushCmd = new Command("push").description("Push the product registry (and an
   let exposure;
   if (opts.result) {
     const raw = path43.resolve(rootDir, opts.result);
-    const resultPath = fs12.existsSync(raw) && fs12.statSync(raw).isDirectory() ? path43.join(raw, "result.json") : raw;
-    if (!fs12.existsSync(resultPath)) throw new CliError(`no result.json at ${opts.result}`, ExitCode.NOT_FOUND);
-    exposure = JSON.parse(fs12.readFileSync(resultPath, "utf8"));
+    const resultPath = fs14.existsSync(raw) && fs14.statSync(raw).isDirectory() ? path43.join(raw, "result.json") : raw;
+    if (!fs14.existsSync(resultPath)) throw new CliError(`no result.json at ${opts.result}`, ExitCode.NOT_FOUND);
+    exposure = JSON.parse(fs14.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);
@@ -14507,7 +14206,7 @@ function dispatch(argv, cwd) {
   }
   const looksLikeQuestion = /\s/.test(first) || first.endsWith("?");
   if (looksLikeQuestion) return ["ask", ...args];
-  if (fs12.existsSync(path43.resolve(cwd, first))) {
+  if (fs14.existsSync(path43.resolve(cwd, first))) {
     return [hasBuildOnlyFlag(args) ? "build" : "scan", ...args];
   }
   const moved = MOVED_COMMANDS[first];