@vibgrate/cli 2026.720.1 → 2026.720.3

package/dist/cli.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import { resolveDsn, resolveIngestHost, dashHostForIngestHost, resolveCliInvocation, availableRegionIds, createWorkspaceDsn, writeStoredCredentials, credentialsPath, findGitRoot, ensureGitignored, gitignoreEntryForCredentials, clearStoredCredentials, inventory, uploadScanArtifact, ingestHostForRegionId, dsnCommand, pushCommand, CliError, ExitCode, NPX_INVOCATION, refreshIfStale, driftCount, embeddingsCached, resolveEmbedModel, loadEmbedder, getNodeEmbeddings, queryGraphSemantic, queryGraph, unavailableMessage, recordCliCall, CLI_TOOL_ALIASES, countPending, resolveOne, indexFor, countTokens, shortestPath, renderReport, impactOf, testsToRun, detectRunner, defaultGraphPath, serveStdio, ASSISTANTS, detectAssistants, usageError, loadGraph, detectServeLaunch, installAssistant, writeNavigationConfig, uninstallAssistant, coveringTests, FREE_PACK, readScanArtifact, enrichOnline, ECOSYSTEMS, discoverModels, readSavings, readUsage, exportGraph, catalogPath, libDir, stableStringify, buildGraph, writeArtifacts, writeSnapshot, UsageError, ResourceLimitError, epistemicBreakdown, cacheDir, probeFreshness, discover, vibgrateDir, modelCacheInfo, clearModelCache, GraphSource, createServer, assistantById, serializeGraph, resolveLimits, loadCatalog, driftFor, addLibrary, parseDsn as parseDsn$1, publishPrivateLibrary, resolveLib, libId, resolveVersion, readDoc, localPackageDocs, localApiSurface, assessDocQuality, symbolsFromApi, fetchHostedDocsCached, selectForBudget, formatForExt, hostedBase, verifyDeterminism, renderHtml, isModelReady, SAVINGS_TOOLS, DEFAULT_RATE_LABEL, readStoredCredentials, projectCredentialsPath, DEFAULT_RATE_PER_M, homeCredentialsPath, SKIP_DIRS, SKIP_FILES } from './chunk-VQLOVQZP.js';
-import { resolvedGrammarFiles, grammarSetVersion, hashString, canonicalize, hashBytes } from './chunk-VFO5UDAT.js';
-import { loadAdvancedScanHook, baselineCommand } from './chunk-VYSTOEAK.js';
-import { ensureDir, pathExists, writeDefaultConfig, parseDsn, detectVcs, computeRepoFingerprint, resolveRepositoryName, fetchScanPreflight, runCoreScan, VERSION, readJsonFile, writeTextFile, loadConfig, prepareCompressedUpload, computeDriftScore, titleBox, projectTypeToVulnEcosystem, driftBar, gitHistoryAvailable, buildVersionTimelines, findPackageAnyEcosystem, normalizeConstraint, findVersionCrossings, versionSatisfies, PROJECT_TYPE_TO_OSV_ECOSYSTEM, fetchRiskySymbols, brandProgressBar, resolveHead, workingTreeDirty } from './chunk-AJDUMRVI.js';
+import { resolveDsn, resolveIngestHost, dashHostForIngestHost, resolveCliInvocation, availableRegionIds, createWorkspaceDsn, writeStoredCredentials, credentialsPath, findGitRoot, ensureGitignored, gitignoreEntryForCredentials, clearStoredCredentials, inventory, uploadScanArtifact, ingestHostForRegionId, dsnCommand, pushCommand, CliError, ExitCode, NPX_INVOCATION, refreshIfStale, driftCount, embeddingsCached, resolveEmbedModel, loadEmbedder, getNodeEmbeddings, queryGraphSemantic, queryGraph, unavailableMessage, recordCliCall, CLI_TOOL_ALIASES, countPending, resolveOne, indexFor, countTokens, shortestPath, renderReport, impactOf, testsToRun, detectRunner, defaultGraphPath, savingsLedgerPath, serveStdio, ASSISTANTS, detectAssistants, usageError, loadGraph, detectServeLaunch, installAssistant, writeNavigationConfig, uninstallAssistant, coveringTests, FREE_PACK, readScanArtifact, enrichOnline, ECOSYSTEMS, discoverModels, readSavings, readUsage, exportGraph, catalogPath, libDir, stableStringify, buildGraph, writeArtifacts, writeSnapshot, UsageError, ResourceLimitError, refreshInstalledInstructions, SMALL_REPO_FILES, epistemicBreakdown, cacheDir, probeFreshness, discover, vibgrateDir, modelCacheInfo, clearModelCache, GraphSource, createServer, assistantById, serializeGraph, resolveLimits, loadCatalog, driftFor, addLibrary, parseDsn as parseDsn$1, publishPrivateLibrary, resolveLib, libId, resolveVersion, readDoc, localPackageDocs, localApiSurface, assessDocQuality, symbolsFromApi, fetchHostedDocsCached, selectForBudget, formatForExt, hostedBase, verifyDeterminism, renderHtml, isModelReady, SAVINGS_TOOLS, sanitizeClient, readStoredCredentials, projectCredentialsPath, homeCredentialsPath, SKIP_DIRS, SKIP_FILES } from './chunk-ZFDVHKID.js';
+import { resolvedGrammarFiles, grammarSetVersion, hashString, canonicalize, hashBytes } from './chunk-BHA7QIPD.js';
+import { loadAdvancedScanHook, baselineCommand } from './chunk-IUKCKMR6.js';
+import { ensureDir, pathExists, writeDefaultConfig, parseDsn, detectVcs, computeRepoFingerprint, resolveRepositoryName, fetchScanPreflight, runCoreScan, VERSION, readJsonFile, writeTextFile, loadConfig, prepareCompressedUpload, computeDriftScore, titleBox, projectTypeToVulnEcosystem, driftBar, gitHistoryAvailable, buildVersionTimelines, findPackageAnyEcosystem, normalizeConstraint, findVersionCrossings, versionSatisfies, PROJECT_TYPE_TO_OSV_ECOSYSTEM, fetchRiskySymbols, brandProgressBar, resolveHead, workingTreeDirty } from './chunk-B6ZWB3WH.js';
 import './chunk-RXP66R2E.js';
 import { pathExists as pathExists$1, parseExcludePatterns } from './chunk-GI6W53LM.js';
-import * as fs8 from 'fs';
-import fs8__default, { realpathSync } from 'fs';
+import * as fs10 from 'fs';
+import fs10__default, { realpathSync } from 'fs';
 import * as path from 'path';
 import path__default from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
@@ -16,7 +16,7 @@ import * as crypto from 'crypto';
 import { randomUUID } from 'crypto';
 import chalk8 from 'chalk';
 import * as os from 'os';
-import * as fs15 from 'fs/promises';
+import * as fs17 from 'fs/promises';
 import * as readline from 'readline';
 import semver from 'semver';
 
@@ -178,14 +178,14 @@ async function signGraphAttestation(root, graph, opts) {
   const explicitKey = opts.key ?? process.env.VG_ATTEST_KEY;
   const keyPath = explicitKey ? path.resolve(explicitKey) : path.join(root, ".vibgrate", DEFAULT_KEY);
   let keyGeneratedAt;
-  if (!fs8.existsSync(keyPath)) {
+  if (!fs10.existsSync(keyPath)) {
     if (explicitKey) {
       throw new CliError(`signing key not found: ${explicitKey}`, ExitCode.USAGE_ERROR);
     }
     const kp = generateKeypair();
-    fs8.mkdirSync(path.dirname(keyPath), { recursive: true });
-    fs8.writeFileSync(keyPath, kp.privatePem, { mode: 384 });
-    fs8.writeFileSync(`${keyPath}.pub`, kp.publicPem);
+    fs10.mkdirSync(path.dirname(keyPath), { recursive: true });
+    fs10.writeFileSync(keyPath, kp.privatePem, { mode: 384 });
+    fs10.writeFileSync(`${keyPath}.pub`, kp.publicPem);
     keyGeneratedAt = keyPath;
     notices.push(
       `minted a new Ed25519 signing key at ${rel(root, keyPath)} (keyid ${kp.keyid}) \u2014 keep it, add it to .gitignore, and reuse it to re-sign reproducibly`
@@ -193,7 +193,7 @@ async function signGraphAttestation(root, graph, opts) {
   }
   let privateKey;
   try {
-    privateKey = crypto.createPrivateKey(fs8.readFileSync(keyPath, "utf8"));
+    privateKey = crypto.createPrivateKey(fs10.readFileSync(keyPath, "utf8"));
   } catch {
     throw new CliError(`could not read an Ed25519 private key from ${rel(root, keyPath)}`, ExitCode.USAGE_ERROR);
   }
@@ -207,8 +207,8 @@ async function signGraphAttestation(root, graph, opts) {
   const statement = buildStatement(graph, { commit });
   const envelope = signStatement(statement, privateKey);
   const outPath = opts.attestation ? path.resolve(opts.attestation) : path.join(root, ".vibgrate", DEFAULT_ATTESTATION);
-  fs8.mkdirSync(path.dirname(outPath), { recursive: true });
-  fs8.writeFileSync(outPath, serializeEnvelope(envelope));
+  fs10.mkdirSync(path.dirname(outPath), { recursive: true });
+  fs10.writeFileSync(outPath, serializeEnvelope(envelope));
   return {
     summary: {
       keyid: envelope.signatures[0]?.keyid ?? "",
@@ -223,7 +223,7 @@ async function signGraphAttestation(root, graph, opts) {
 }
 function verifyGraphAttestation(root, opts) {
   const bundlePath = opts.attestation ? path.resolve(opts.attestation) : path.join(root, ".vibgrate", DEFAULT_ATTESTATION);
-  if (!fs8.existsSync(bundlePath)) {
+  if (!fs10.existsSync(bundlePath)) {
     if (opts.attestation || opts.pub) {
       throw new CliError(
         `no attestation at ${rel(root, bundlePath)} \u2014 sign one with \`vg build --attest\``,
@@ -232,8 +232,8 @@ function verifyGraphAttestation(root, opts) {
     }
     return { bundlePath, missing: true };
   }
-  const envelope = parseEnvelope(fs8.readFileSync(bundlePath, "utf8"));
-  const publicKeyPem = opts.pub ? fs8.readFileSync(path.resolve(opts.pub), "utf8") : void 0;
+  const envelope = parseEnvelope(fs10.readFileSync(bundlePath, "utf8"));
+  const publicKeyPem = opts.pub ? fs10.readFileSync(path.resolve(opts.pub), "utf8") : void 0;
   const graph = loadGraph(root) ?? void 0;
   return { bundlePath, missing: false, result: verifyEnvelope(envelope, { publicKeyPem, graph }) };
 }
@@ -431,6 +431,15 @@ async function runBuild(paths, opts, global) {
     });
   }
   if (opts.export) writeExport(result.graph, opts.export);
+  if (!global.graph) {
+    const fileCount = result.graph.nodes.filter((n) => n.kind === "file").length;
+    const refreshed = refreshInstalledInstructions(root, fileCount > 0 && fileCount < SMALL_REPO_FILES);
+    if (interactive) {
+      for (const r of refreshed) {
+        info(c.dim(`vg \xB7 refreshed assistant instructions ${r.file} (v${r.from} \u2192 v${r.to})`));
+      }
+    }
+  }
   let attestation;
   const attestNotices = [];
   if (opts.attest) {
@@ -586,8 +595,8 @@ function writeExport(graph, target) {
         ExitCode.USAGE_ERROR
       );
   }
-  fs8.mkdirSync(path.dirname(path.resolve(target)), { recursive: true });
-  fs8.writeFileSync(target, content);
+  fs10.mkdirSync(path.dirname(path.resolve(target)), { recursive: true });
+  fs10.writeFileSync(target, content);
 }
 function collect(value, prev) {
   return [...prev, value];
@@ -606,7 +615,7 @@ async function runStatus(global) {
   const root = path.resolve(global.cwd ?? ".");
   const graphPath = global.graph ?? defaultGraphPath(root);
   const graph = loadGraph(root, graphPath);
-  const hasCache = fs8.existsSync(path.join(cacheDir(root), "parse-cache.json"));
+  const hasCache = fs10.existsSync(path.join(cacheDir(root), "parse-cache.json"));
   let stale = null;
   let staleExact = false;
   if (graph) {
@@ -1315,14 +1324,14 @@ function isCI(env = process.env) {
 function installId(env = process.env) {
   if (telemetryOptOut(env) !== null || isCI(env)) return randomUuid();
   try {
-    const existing = fs8.readFileSync(INSTALL_ID_FILE, "utf8").trim();
+    const existing = fs10.readFileSync(INSTALL_ID_FILE, "utf8").trim();
     if (isUuid(existing)) return existing;
   } catch {
   }
   const id = randomUuid();
   try {
-    fs8.mkdirSync(INSTALL_ID_DIR, { recursive: true });
-    fs8.writeFileSync(INSTALL_ID_FILE, id + "\n", { mode: 384 });
+    fs10.mkdirSync(INSTALL_ID_DIR, { recursive: true });
+    fs10.writeFileSync(INSTALL_ID_FILE, id + "\n", { mode: 384 });
   } catch {
   }
   return id;
@@ -1346,7 +1355,7 @@ function ledgerFilePath(root) {
 }
 function readOffset(root) {
   try {
-    const raw = JSON.parse(fs8.readFileSync(offsetPath(root), "utf8"));
+    const raw = JSON.parse(fs10.readFileSync(offsetPath(root), "utf8"));
     return typeof raw.offset === "number" && raw.offset >= 0 ? raw.offset : 0;
   } catch {
     return 0;
@@ -1354,8 +1363,8 @@ function readOffset(root) {
 }
 function writeOffset(root, offset) {
   try {
-    fs8.mkdirSync(cacheDir(root), { recursive: true });
-    fs8.writeFileSync(offsetPath(root), JSON.stringify({ offset }) + "\n");
+    fs10.mkdirSync(cacheDir(root), { recursive: true });
+    fs10.writeFileSync(offsetPath(root), JSON.stringify({ offset }) + "\n");
   } catch {
   }
 }
@@ -1363,7 +1372,7 @@ function buildBatch(root, fromOffset, id = installId()) {
   const file = ledgerFilePath(root);
   let size = 0;
   try {
-    size = fs8.statSync(file).size;
+    size = fs10.statSync(file).size;
   } catch {
     return { batch: null, newOffset: 0 };
   }
@@ -1371,13 +1380,13 @@ function buildBatch(root, fromOffset, id = installId()) {
   if (start >= size) return { batch: null, newOffset: size };
   let text = "";
   try {
-    const fd = fs8.openSync(file, "r");
+    const fd = fs10.openSync(file, "r");
     try {
       const buf = Buffer.alloc(size - start);
-      fs8.readSync(fd, buf, 0, buf.length, start);
+      fs10.readSync(fd, buf, 0, buf.length, start);
       text = buf.toString("utf8");
     } finally {
-      fs8.closeSync(fd);
+      fs10.closeSync(fd);
     }
   } catch {
     return { batch: null, newOffset: fromOffset };
@@ -1509,10 +1518,143 @@ function isLoopbackOrigin(origin) {
   if (host === "localhost" || host === "[::1]" || host === "::1") return true;
   return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(host);
 }
+var PUBLISH_INTERVAL_MS = 2e3;
+var KEEPALIVE_MS = 1e4;
+var STALE_MS = 6e4;
+function liveStatsDir(root) {
+  return path.join(cacheDir(root), "serve-live");
+}
+var LiveStatsBus = class {
+  constructor(dir, stats, pid = process.pid) {
+    this.dir = dir;
+    this.stats = stats;
+    this.pid = pid;
+    this.file = path.join(dir, `serve-${this.pid}.json`);
+  }
+  dir;
+  stats;
+  pid;
+  timer = null;
+  lastRevision = -1;
+  lastWriteAt = 0;
+  file;
+  start() {
+    if (this.timer) return;
+    this.publish();
+    this.timer = setInterval(() => this.publish(), PUBLISH_INTERVAL_MS);
+    this.timer.unref?.();
+    process.on("exit", this.unlinkOwn);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    process.removeListener("exit", this.unlinkOwn);
+    this.unlinkOwn();
+  }
+  /** Write the current snapshot when it changed (or as a keepalive). Never throws. */
+  publish(now2 = Date.now()) {
+    const snap = this.stats.snapshot();
+    if (snap.revision === this.lastRevision && now2 - this.lastWriteAt < KEEPALIVE_MS) return;
+    this.lastRevision = snap.revision;
+    this.lastWriteAt = now2;
+    const body = { pid: this.pid, updatedAt: now2, snapshot: snap };
+    try {
+      fs10.mkdirSync(this.dir, { recursive: true });
+      const tmp = `${this.file}.tmp`;
+      fs10.writeFileSync(tmp, JSON.stringify(body));
+      fs10.renameSync(tmp, this.file);
+    } catch {
+    }
+  }
+  /**
+   * Fresh snapshots of the OTHER serve processes in this repo. Stale files
+   * (crashed processes) are swept best-effort while reading.
+   */
+  siblings(now2 = Date.now()) {
+    let entries;
+    try {
+      entries = fs10.readdirSync(this.dir);
+    } catch {
+      return [];
+    }
+    const out2 = [];
+    for (const name of entries.sort()) {
+      if (!/^serve-\d+\.json$/.test(name)) continue;
+      const file = path.join(this.dir, name);
+      let parsed;
+      try {
+        parsed = JSON.parse(fs10.readFileSync(file, "utf8"));
+      } catch {
+        continue;
+      }
+      if (typeof parsed?.pid !== "number" || typeof parsed.updatedAt !== "number" || !parsed.snapshot?.totals) continue;
+      if (now2 - parsed.updatedAt > STALE_MS) {
+        try {
+          fs10.unlinkSync(file);
+        } catch {
+        }
+        continue;
+      }
+      if (parsed.pid === this.pid) continue;
+      out2.push(parsed.snapshot);
+    }
+    return out2;
+  }
+  unlinkOwn = () => {
+    try {
+      fs10.unlinkSync(this.file);
+    } catch {
+    }
+  };
+};
+function addInto(target, add) {
+  target.calls += add.calls;
+  target.complete += add.complete;
+  target.partial += add.partial;
+  target.miss += add.miss;
+  target.timed += add.timed;
+  target.totalMs += add.totalMs;
+  target.vgTokens += add.vgTokens;
+  target.baselineTokens += add.baselineTokens;
+}
+function mergeRows(base, extra) {
+  const byKey = new Map(base.map((r) => [r.key, { ...r }]));
+  for (const row of extra) {
+    const hit = byKey.get(row.key);
+    if (hit) addInto(hit, row);
+    else byKey.set(row.key, { ...row });
+  }
+  return [...byKey.values()].sort((a, b) => b.calls - a.calls || a.key.localeCompare(b.key));
+}
+function mergeSnapshots(own, siblings) {
+  if (!siblings.length) return own;
+  const merged = {
+    startedAt: own.startedAt,
+    revision: own.revision,
+    lastCallAt: own.lastCallAt,
+    totals: { ...own.totals },
+    clients: [...own.clients.map((r) => ({ ...r }))],
+    tools: [...own.tools.map((r) => ({ ...r }))],
+    sources: [...own.sources.map((r) => ({ ...r }))]
+  };
+  for (const s of siblings) {
+    merged.revision += s.revision;
+    if (s.lastCallAt !== null && (merged.lastCallAt === null || s.lastCallAt > merged.lastCallAt)) {
+      merged.lastCallAt = s.lastCallAt;
+    }
+    addInto(merged.totals, s.totals);
+    merged.clients = mergeRows(merged.clients, s.clients);
+    merged.tools = mergeRows(merged.tools, s.tools);
+    merged.sources = mergeRows(merged.sources, s.sources);
+  }
+  return merged;
+}
 
 // src/mcp/serve-stats.ts
 function zeroRow(key2) {
-  return { key: key2, calls: 0, complete: 0, partial: 0, miss: 0, totalMs: 0, vgTokens: 0, baselineTokens: 0 };
+  return { key: key2, calls: 0, complete: 0, partial: 0, miss: 0, timed: 0, totalMs: 0, vgTokens: 0, baselineTokens: 0 };
 }
 var SessionStats = class {
   startedAt;
@@ -1521,16 +1663,26 @@ var SessionStats = class {
   totals = zeroRow("total");
   byClient = /* @__PURE__ */ new Map();
   byTool = /* @__PURE__ */ new Map();
+  bySource = /* @__PURE__ */ new Map();
   constructor(now2 = Date.now()) {
     this.startedAt = now2;
   }
   record(sample, now2 = Date.now()) {
     this.revision++;
     this.lastCallAt = now2;
-    for (const row of [this.totals, this.rowFor(this.byClient, sample.client), this.rowFor(this.byTool, sample.tool)]) {
+    const rows = [
+      this.totals,
+      this.rowFor(this.byClient, sample.client),
+      this.rowFor(this.byTool, sample.tool),
+      this.rowFor(this.bySource, sample.source ?? "mcp")
+    ];
+    for (const row of rows) {
       row.calls++;
       row[sample.outcome]++;
-      row.totalMs += sample.ms;
+      if (typeof sample.ms === "number") {
+        row.timed++;
+        row.totalMs += sample.ms;
+      }
       row.vgTokens += sample.vgTokens;
       row.baselineTokens += sample.baselineTokens;
     }
@@ -1543,7 +1695,8 @@ var SessionStats = class {
       lastCallAt: this.lastCallAt,
       totals: { ...this.totals },
       clients: sorted(this.byClient),
-      tools: sorted(this.byTool)
+      tools: sorted(this.byTool),
+      sources: sorted(this.bySource)
     };
   }
   rowFor(m, key2) {
@@ -1571,29 +1724,33 @@ function fmtTokens(n) {
   return String(n);
 }
 function fmtAvgMs(row) {
-  if (row.calls === 0) return "\u2014";
-  const avg = row.totalMs / row.calls;
+  if (row.timed === 0) return "\u2014";
+  const avg = row.totalMs / row.timed;
   return avg >= 1e3 ? `${(avg / 1e3).toFixed(1)}s` : `${Math.round(avg)}ms`;
 }
 var teal2 = (s) => c.hex("#3FB0A4")(s);
 var mint2 = (s) => c.hex("#4FE3C1")(s);
 var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var MAX_TOOL_ROWS = 8;
-function serveStatusLines(snap, now2, tick = 0) {
+function serveStatusLines(snap, now2, tick = 0, siblingServers = 0) {
   const spinner = mint2(SPINNER[tick % SPINNER.length]);
   const up = fmtUptime(now2 - snap.startedAt);
   const lines = [];
+  const siblingNote = siblingServers > 0 ? `    ${c.dim(`incl. ${siblingServers} assistant-spawned server${siblingServers === 1 ? "" : "s"} in this repo`)}` : null;
   if (snap.totals.calls === 0) {
     lines.push(
-      `  ${spinner} ${c.bold.white("vg serve")} ${c.dim("\xB7")} up ${teal2(up)} ${c.dim("\xB7 waiting for your assistant\u2019s first tool call\u2026")}`
+      `  ${spinner} ${c.bold.white("vg serve")} ${c.dim("\xB7")} up ${teal2(up)} ${c.dim("\xB7 waiting for your assistant\u2019s first call (MCP tool call, or `vg \u2026 --client=<ai>` CLI)\u2026")}`
     );
+    if (siblingNote) lines.push(siblingNote);
     return lines;
   }
   const t = snap.totals;
   const answered = Math.round((t.complete + t.partial) / t.calls * 100);
+  const cli = snap.sources.find((s) => s.key === "cli");
+  const via = cli ? c.dim(" \xB7 via ") + snap.sources.map((s) => `${c.white(s.key)} ${teal2(String(s.calls))}`).join(c.dim(" \xB7 ")) : "";
   const ago = snap.lastCallAt === null ? "" : c.dim(` \xB7 last call ${fmtUptime(now2 - snap.lastCallAt)} ago`);
   lines.push(
-    `  ${spinner} ${c.bold.white("vg serve")} ${c.dim("\xB7")} up ${teal2(up)} ${c.dim("\xB7")} ${c.bold.white(String(t.calls))} call${t.calls === 1 ? "" : "s"} ${c.dim("\xB7")} ${mint2(`${answered}%`)} answered${ago}`
+    `  ${spinner} ${c.bold.white("vg serve")} ${c.dim("\xB7")} up ${teal2(up)} ${c.dim("\xB7")} ${c.bold.white(String(t.calls))} call${t.calls === 1 ? "" : "s"} ${c.dim("\xB7")} ${mint2(`${answered}%`)} answered${via}${ago}`
   );
   lines.push(
     `    ${c.dim("clients")}  ` + snap.clients.map((cl) => `${c.white(cl.key)} ${teal2(String(cl.calls))}${c.dim(` (avg ${fmtAvgMs(cl)})`)}`).join(c.dim(" \xB7 "))
@@ -1613,15 +1770,15 @@ function serveStatusLines(snap, now2, tick = 0) {
   }
   if (t.baselineTokens > 0) {
     const savedTokens = Math.max(0, t.baselineTokens - t.vgTokens);
-    const savedUsd = savedTokens / 1e6 * DEFAULT_RATE_PER_M;
     const ratio = t.vgTokens > 0 ? (t.baselineTokens / t.vgTokens).toFixed(1) : "\u2014";
     lines.push(
       `    ${c.dim("session")}  ctx ${c.bold.white(fmtTokens(t.vgTokens))} ` + c.dim(`vs grep/read \u2248${fmtTokens(t.baselineTokens)} \u2192 `) + mint2(`${ratio}\xD7 fewer`)
     );
     lines.push(
-      `    ${c.dim("est. saved \u2248")} ${mint2(`${fmtTokens(savedTokens)} tokens ($${savedUsd.toFixed(2)})`)} ` + c.dim(`(${DEFAULT_RATE_LABEL}; estimate)`)
+      `    ${c.dim("est. saved \u2248")} ${mint2(`${fmtTokens(savedTokens)} context tokens`)} ${c.dim("(estimate)")}`
     );
   }
+  if (siblingNote) lines.push(siblingNote);
   return lines;
 }
 function serveHeartbeatLine(snap, now2) {
@@ -1629,7 +1786,9 @@ function serveHeartbeatLine(snap, now2) {
   const t = snap.totals;
   if (t.calls === 0) return c.dim(`vg \xB7 serving for ${up} \u2014 no tool calls yet`);
   const clients = snap.clients.map((cl) => `${cl.key} ${cl.calls}`).join(", ");
+  const cli = snap.sources.find((s) => s.key === "cli");
   let line = `vg \xB7 serving for ${up} \u2014 ${t.calls} call${t.calls === 1 ? "" : "s"} (${clients})`;
+  if (cli) line += ` \xB7 ${cli.calls} via CLI`;
   if (t.baselineTokens > 0) {
     const savedTokens = Math.max(0, t.baselineTokens - t.vgTokens);
     line += ` \xB7 ctx ${fmtTokens(t.vgTokens)} vs \u2248${fmtTokens(t.baselineTokens)} grep/read \xB7 est. saved \u2248 ${fmtTokens(savedTokens)} tokens`;
@@ -1639,13 +1798,15 @@ function serveHeartbeatLine(snap, now2) {
 var TTY_INTERVAL_MS = 1e3;
 var HEARTBEAT_INTERVAL_MS = 15 * 60 * 1e3;
 var ServeStatusDisplay = class {
-  constructor(stats, stream = process.stderr) {
+  constructor(stats, stream = process.stderr, siblings) {
     this.stats = stats;
     this.stream = stream;
+    this.siblings = siblings;
     this.isTTY = (stream.isTTY ?? false) && process.env.VIBGRATE_PROGRESS_MODE !== "plain";
   }
   stats;
   stream;
+  siblings;
   timer = null;
   tick = 0;
   lastRowCount = 0;
@@ -1688,7 +1849,9 @@ var ServeStatusDisplay = class {
   }
   renderTTY() {
     this.tick++;
-    const lines = serveStatusLines(this.stats.snapshot(), Date.now(), this.tick);
+    const sibs = this.siblings?.() ?? [];
+    const snap = mergeSnapshots(this.stats.snapshot(), sibs);
+    const lines = serveStatusLines(snap, Date.now(), this.tick, sibs.length);
     const content = lines.join("\n") + "\n";
     if (content === this.lastFrame) return;
     this.lastFrame = content;
@@ -1723,6 +1886,89 @@ var ServeStatusDisplay = class {
     this.cursorHidden = false;
   };
 };
+var POLL_INTERVAL_MS = 2e3;
+var LedgerTail = class {
+  constructor(file, stats, intervalMs = POLL_INTERVAL_MS) {
+    this.file = file;
+    this.stats = stats;
+    this.intervalMs = intervalMs;
+  }
+  file;
+  stats;
+  intervalMs;
+  timer = null;
+  /** Byte offset of the next unread ledger byte (always at a line boundary). */
+  offset = 0;
+  start() {
+    if (this.timer) return;
+    this.offset = this.sizeOf();
+    this.timer = setInterval(() => this.poll(), this.intervalMs);
+    this.timer.unref?.();
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  /** One poll cycle — exposed for tests (deterministic, no timers needed). */
+  poll(now2 = Date.now()) {
+    let size;
+    try {
+      size = this.sizeOf();
+    } catch {
+      return;
+    }
+    if (size < this.offset) this.offset = 0;
+    if (size === this.offset) return;
+    let chunk;
+    try {
+      const fd = fs10.openSync(this.file, "r");
+      try {
+        chunk = Buffer.alloc(size - this.offset);
+        fs10.readSync(fd, chunk, 0, chunk.length, this.offset);
+      } finally {
+        fs10.closeSync(fd);
+      }
+    } catch {
+      return;
+    }
+    const lastNewline = chunk.lastIndexOf(10);
+    if (lastNewline < 0) return;
+    const text = chunk.subarray(0, lastNewline).toString("utf8");
+    this.offset += lastNewline + 1;
+    for (const line of text.split("\n")) ingestLedgerLine(this.stats, line, now2);
+  }
+  sizeOf() {
+    try {
+      return fs10.statSync(this.file).size;
+    } catch {
+      return 0;
+    }
+  }
+};
+function ingestLedgerLine(stats, line, now2) {
+  if (!line.trim()) return;
+  let e;
+  try {
+    e = JSON.parse(line);
+  } catch {
+    return;
+  }
+  if (e.source !== "cli" || typeof e.tool !== "string") return;
+  stats.record(
+    {
+      tool: e.tool,
+      client: sanitizeClient(e.client),
+      outcome: e.outcome ?? "complete",
+      source: "cli",
+      // CLI lines carry no wall time — leave ms absent ("not measured").
+      vgTokens: e.vgTokens ?? 0,
+      baselineTokens: e.baselineTokens ?? 0
+    },
+    now2
+  );
+}
 
 // src/commands/serve.ts
 var SHARE_FLUSH_INTERVAL_MS = 5 * 60 * 1e3;
@@ -1759,7 +2005,11 @@ function registerServe(program) {
       info(c.dim(`vg \xB7 --share-stats disabled by ${optOut}: recording locally, not uploading.`));
     }
     if (shareStats) startSharing(root);
-    const display = stats ? new ServeStatusDisplay(stats) : void 0;
+    const interactive = process.stderr.isTTY === true;
+    const bus = stats ? new LiveStatsBus(liveStatsDir(root), stats) : void 0;
+    if (bus && !interactive) bus.start();
+    const display = stats ? new ServeStatusDisplay(stats, process.stderr, bus && interactive ? () => bus.siblings() : void 0) : void 0;
+    if (stats && interactive) new LedgerTail(savingsLedgerPath(root), stats).start();
     const freshness = refresh ? "auto-refresh" : "as built";
     if (opts.http) {
       await serveHttp(graphPath, opts.host ?? "127.0.0.1", Number(opts.port) || 7437, serveOpts, freshness, () => display?.start());
@@ -1773,7 +2023,7 @@ function registerServe(program) {
 }
 async function ensureServableGraph(root, graphPath, global, refresh, opts = {}) {
   if (refresh) {
-    if (!fs8.existsSync(graphPath)) {
+    if (!fs10.existsSync(graphPath)) {
       info(c.dim("vg \xB7 no map found \u2014 building it before serving\u2026"));
       await runBuild(
         [],
@@ -1790,7 +2040,7 @@ async function ensureServableGraph(root, graphPath, global, refresh, opts = {})
       }
     }
   }
-  if (!fs8.existsSync(graphPath)) {
+  if (!fs10.existsSync(graphPath)) {
     throw new CliError(
       `no map found at ${graphPath} \u2014 run \`vg\` to build one first`,
       ExitCode.NOT_FOUND
@@ -2073,7 +2323,7 @@ function manifestHash(root) {
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = fs8.readdirSync(dir, { withFileTypes: true });
+      entries = fs10.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -2089,7 +2339,7 @@ function manifestHash(root) {
       if (!isManifest(abs) && !SKIP_FILES.has(base)) continue;
       try {
         const rel3 = path.relative(root, abs).split(path.sep).join("/");
-        files.push({ rel: rel3, hash: hashBytes(fs8.readFileSync(abs)) });
+        files.push({ rel: rel3, hash: hashBytes(fs10.readFileSync(abs)) });
       } catch {
       }
     }
@@ -2100,7 +2350,7 @@ function manifestHash(root) {
 }
 function loadScanCache(root, key2) {
   try {
-    const raw = JSON.parse(fs8.readFileSync(cachePath(root), "utf8"));
+    const raw = JSON.parse(fs10.readFileSync(cachePath(root), "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 };
     }
@@ -2110,8 +2360,8 @@ function loadScanCache(root, key2) {
 }
 function writeScanCache(root, key2, artifact) {
   try {
-    fs8.mkdirSync(cacheDir(root), { recursive: true });
-    fs8.writeFileSync(
+    fs10.mkdirSync(cacheDir(root), { recursive: true });
+    fs10.writeFileSync(
       cachePath(root),
       stableStringify(
         { version: CACHE_VERSION, manifestHash: key2.manifestHash, toolVersion: key2.toolVersion, offline: key2.offline, artifact },
@@ -2935,7 +3185,7 @@ function hoverMarkdown(dep, contribution) {
   return lines.join("\n");
 }
 function startLanguageServer(opts) {
-  if (!fs8.existsSync(opts.root)) {
+  if (!fs10.existsSync(opts.root)) {
     process.stderr.write(`vg lsp: root does not exist: ${opts.root}
 `);
     process.exit(1);
@@ -2979,7 +3229,6 @@ function registerLsp(program) {
 }
 
 // src/commands/install.ts
-var SMALL_REPO_FILES = 150;
 function registerInstall(program) {
   const install = program.command("install").description("add vg to your AI assistant(s): skill + MCP + advisory nudge").argument("[tools...]", `assistant ids: ${ASSISTANTS.map((a) => a.id).join(", ")}`).option("--all", "install for every supported assistant").option("--detect", "detect assistants in use (repo footprint, home config, PATH) and install for those; with --list, only report what was detected").option("--list", "show the support matrix and exit").option("--no-hook", "skip the advisory nudge").action(function(tools, opts) {
     const global = readGlobal(this);
@@ -3074,7 +3323,7 @@ function registerShare(program) {
     const global = readGlobal(this);
     const root = rootOf(global);
     const gitDir = path.join(root, ".git");
-    if (!fs8.existsSync(gitDir)) {
+    if (!fs10.existsSync(gitDir)) {
       throw new CliError("not a git repository \u2014 run `vg share` inside a git repo", ExitCode.USAGE_ERROR);
     }
     if (opts.undo) {
@@ -3096,22 +3345,22 @@ function registerShare(program) {
 }
 function writeVibgrateGitignore(root, reports) {
   const dir = path.join(root, ".vibgrate");
-  fs8.mkdirSync(dir, { recursive: true });
+  fs10.mkdirSync(dir, { recursive: true });
   const lines = ["# Managed by `vg share` \u2014 keep graph.json committed, ignore the rest", "cache/", "facts.jsonl"];
   if (!reports) lines.push("graph.html", "GRAPH_REPORT.md");
-  fs8.writeFileSync(path.join(dir, ".gitignore"), `${lines.join("\n")}
+  fs10.writeFileSync(path.join(dir, ".gitignore"), `${lines.join("\n")}
 `);
 }
 function writeGitAttributes(root) {
   const file = path.join(root, ".gitattributes");
   const line = ".vibgrate/graph.json merge=vg";
-  let content = fs8.existsSync(file) ? fs8.readFileSync(file, "utf8") : "";
+  let content = fs10.existsSync(file) ? fs10.readFileSync(file, "utf8") : "";
   if (!content.split("\n").some((l) => l.trim() === line)) {
     content = content.length ? `${content.replace(/\s*$/, "")}
 ${line}
 ` : `${line}
 `;
-    fs8.writeFileSync(file, content);
+    fs10.writeFileSync(file, content);
   }
 }
 function configureMergeDriver(root) {
@@ -3120,7 +3369,7 @@ function configureMergeDriver(root) {
 }
 function installPreCommitHook(root) {
   const hooksDir = hookDir(root);
-  fs8.mkdirSync(hooksDir, { recursive: true });
+  fs10.mkdirSync(hooksDir, { recursive: true });
   const file = path.join(hooksDir, "pre-commit");
   const block = [
     HOOK_BEGIN,
@@ -3130,7 +3379,7 @@ function installPreCommitHook(root) {
     "fi",
     HOOK_END
   ].join("\n");
-  let content = fs8.existsSync(file) ? fs8.readFileSync(file, "utf8") : "#!/bin/sh\n";
+  let content = fs10.existsSync(file) ? fs10.readFileSync(file, "utf8") : "#!/bin/sh\n";
   const re = new RegExp(`${escapeRe(HOOK_BEGIN)}[\\s\\S]*?${escapeRe(HOOK_END)}`);
   if (re.test(content)) content = content.replace(re, block);
   else content = `${content.replace(/\s*$/, "")}
@@ -3139,21 +3388,21 @@ ${block}
 `;
   if (!content.startsWith("#!")) content = `#!/bin/sh
 ${content}`;
-  fs8.writeFileSync(file, content);
-  fs8.chmodSync(file, 493);
+  fs10.writeFileSync(file, content);
+  fs10.chmodSync(file, 493);
 }
 function undo(root) {
   const hookFile = path.join(hookDir(root), "pre-commit");
-  if (fs8.existsSync(hookFile)) {
+  if (fs10.existsSync(hookFile)) {
     const re = new RegExp(`\\n*${escapeRe(HOOK_BEGIN)}[\\s\\S]*?${escapeRe(HOOK_END)}\\n*`);
-    const next2 = fs8.readFileSync(hookFile, "utf8").replace(re, "\n");
-    if (next2.trim() === "#!/bin/sh") fs8.rmSync(hookFile);
-    else fs8.writeFileSync(hookFile, next2);
+    const next2 = fs10.readFileSync(hookFile, "utf8").replace(re, "\n");
+    if (next2.trim() === "#!/bin/sh") fs10.rmSync(hookFile);
+    else fs10.writeFileSync(hookFile, next2);
   }
   const attr = path.join(root, ".gitattributes");
-  if (fs8.existsSync(attr)) {
-    const next2 = fs8.readFileSync(attr, "utf8").split("\n").filter((l) => l.trim() !== ".vibgrate/graph.json merge=vg").join("\n");
-    fs8.writeFileSync(attr, next2);
+  if (fs10.existsSync(attr)) {
+    const next2 = fs10.readFileSync(attr, "utf8").split("\n").filter((l) => l.trim() !== ".vibgrate/graph.json merge=vg").join("\n");
+    fs10.writeFileSync(attr, next2);
   }
   try {
     git(root, ["config", "--remove-section", "merge.vg"]);
@@ -3286,7 +3535,7 @@ function grepBaselineTokens(term, files) {
     if (f.size > 512 * 1024) continue;
     let content = "";
     try {
-      content = fs8.readFileSync(f.abs, "utf8");
+      content = fs10.readFileSync(f.abs, "utf8");
     } catch {
       continue;
     }
@@ -3296,7 +3545,7 @@ function grepBaselineTokens(term, files) {
 }
 function safeSize(abs) {
   try {
-    return fs8.statSync(abs).size;
+    return fs10.statSync(abs).size;
   } catch {
     return 0;
   }
@@ -3630,7 +3879,7 @@ function loadStandards(root) {
     const p = path__default.join(root, rel3);
     let text;
     try {
-      text = fs8__default.readFileSync(p, "utf8");
+      text = fs10__default.readFileSync(p, "utf8");
     } catch {
       continue;
     }
@@ -3869,7 +4118,7 @@ async function addCmd(root, rest, opts, asJson) {
 }
 function readPackageVersion(root) {
   try {
-    const pkg = JSON.parse(fs8__default.readFileSync(path__default.join(root, "package.json"), "utf8"));
+    const pkg = JSON.parse(fs10__default.readFileSync(path__default.join(root, "package.json"), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : void 0;
   } catch {
     return void 0;
@@ -3877,7 +4126,7 @@ function readPackageVersion(root) {
 }
 function readOptionalFile(p) {
   try {
-    const t = fs8__default.readFileSync(p, "utf8");
+    const t = fs10__default.readFileSync(p, "utf8");
     return t.trim() ? t : void 0;
   } catch {
     return void 0;
@@ -4023,8 +4272,8 @@ function registerExport(program) {
       out(content.trimEnd());
       return;
     }
-    fs8.mkdirSync(path.dirname(path.resolve(file)), { recursive: true });
-    fs8.writeFileSync(file, content);
+    fs10.mkdirSync(path.dirname(path.resolve(file)), { recursive: true });
+    fs10.writeFileSync(file, content);
     info(`${c.green("\u2714")} wrote ${file} ${c.dim(`(${format})`)}`);
   });
   applyGlobalOptions(cmd);
@@ -4047,24 +4296,24 @@ function registerBundle(program) {
     } catch {
       throw new CliError("no grammars found to bundle (run a build first)", ExitCode.ERROR);
     }
-    fs8.mkdirSync(path.join(outDir, "grammars"), { recursive: true });
+    fs10.mkdirSync(path.join(outDir, "grammars"), { recursive: true });
     let grammarCount = 0;
     for (const { fileName, absPath } of grammarFiles) {
-      fs8.copyFileSync(absPath, path.join(outDir, "grammars", fileName));
+      fs10.copyFileSync(absPath, path.join(outDir, "grammars", fileName));
       grammarCount++;
     }
     const included = [`grammars/ (${grammarCount} .wasm)`];
     const graphSrc = global.graph ?? defaultGraphPath(root);
-    if (fs8.existsSync(graphSrc)) {
-      fs8.copyFileSync(graphSrc, path.join(outDir, "graph.json"));
+    if (fs10.existsSync(graphSrc)) {
+      fs10.copyFileSync(graphSrc, path.join(outDir, "graph.json"));
       included.push("graph.json");
     }
     const cat = catalogPath(root);
-    if (fs8.existsSync(cat)) {
-      fs8.copyFileSync(cat, path.join(outDir, "vibgrate.lib.json"));
+    if (fs10.existsSync(cat)) {
+      fs10.copyFileSync(cat, path.join(outDir, "vibgrate.lib.json"));
       included.push("vibgrate.lib.json");
-      if (fs8.existsSync(libDir(root))) {
-        fs8.cpSync(libDir(root), path.join(outDir, "lib"), { recursive: true });
+      if (fs10.existsSync(libDir(root))) {
+        fs10.cpSync(libDir(root), path.join(outDir, "lib"), { recursive: true });
         included.push("lib/");
       }
     }
@@ -4076,7 +4325,7 @@ function registerBundle(program) {
       included,
       usage: "Run `vg build --grammars <this dir>/grammars` to build fully offline."
     };
-    fs8.writeFileSync(path.join(outDir, "MANIFEST.json"), `${stableStringify(manifest, 2)}
+    fs10.writeFileSync(path.join(outDir, "MANIFEST.json"), `${stableStringify(manifest, 2)}
 `);
     if (global.json) {
       json({ out: path.relative(root, outDir), ...manifest });
@@ -4100,7 +4349,7 @@ async function runDoctor(global) {
   const root = rootOf(global);
   const local = global.local === true;
   const graphPath = global.graph ?? defaultGraphPath(root);
-  const configFile = CONFIG_BASENAMES.find((f) => fs8.existsSync(path.join(root, f))) ?? null;
+  const configFile = CONFIG_BASENAMES.find((f) => fs10.existsSync(path.join(root, f))) ?? null;
   const graph = loadGraph(root, graphPath);
   let staleFiles = null;
   if (graph) {
@@ -4128,7 +4377,7 @@ async function runDoctor(global) {
     },
     libCatalog: {
       path: path.relative(root, catalogPath(root)),
-      present: fs8.existsSync(catalogPath(root)),
+      present: fs10.existsSync(catalogPath(root)),
       libraries: libCount
     },
     credentials: creds,
@@ -4220,7 +4469,7 @@ var initCommand = new Command("init").description("Initialize vibgrate in a proj
     console.log(chalk8.green("\u2714") + ` Created ${chalk8.bold("vibgrate.config.ts")}`);
   }
   if (opts.baseline) {
-    const { runBaseline } = await import('./baseline-5QPV6API.js');
+    const { runBaseline } = await import('./baseline-FALF7ULT.js');
     await runBaseline(rootDir);
   }
   console.log("");
@@ -4330,9 +4579,9 @@ async function fileReferencesIdentifier(rootDir, relFile, identifier, readFile3)
 }
 async function defaultReadFile(absPath) {
   try {
-    const stat2 = await fs15.stat(absPath);
+    const stat2 = await fs17.stat(absPath);
     if (!stat2.isFile() || stat2.size > MAX_FILE_BYTES) return null;
-    return await fs15.readFile(absPath, "utf8");
+    return await fs17.readFile(absPath, "utf8");
   } catch {
     return null;
   }
@@ -4977,7 +5226,7 @@ var SKIP_DIRS2 = /* @__PURE__ */ new Set([
 function scanStaleness(rootDir, artifactPath) {
   let ref;
   try {
-    ref = fs8.statSync(artifactPath).mtimeMs;
+    ref = fs10.statSync(artifactPath).mtimeMs;
   } catch {
     return { stale: false };
   }
@@ -4989,7 +5238,7 @@ function scanStaleness(rootDir, artifactPath) {
     if (depth > 8 || scanned > MAX_ENTRIES) return;
     let entries;
     try {
-      entries = fs8.readdirSync(dir, { withFileTypes: true });
+      entries = fs10.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -5004,7 +5253,7 @@ function scanStaleness(rootDir, artifactPath) {
       const abs = path.join(dir, e.name);
       let mtimeMs;
       try {
-        mtimeMs = fs8.statSync(abs).mtimeMs;
+        mtimeMs = fs10.statSync(abs).mtimeMs;
       } catch {
         continue;
       }
@@ -5138,7 +5387,7 @@ function analyzeTree(root, packages) {
     if (depth > MAX_DEPTH || filesSeen >= MAX_FILES) return;
     let entries;
     try {
-      entries = fs8.readdirSync(dir, { withFileTypes: true });
+      entries = fs10.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -5156,8 +5405,8 @@ function analyzeTree(root, packages) {
       const full = path.join(dir, entry.name);
       let content;
       try {
-        if (fs8.statSync(full).size > MAX_FILE_BYTES2) continue;
-        content = fs8.readFileSync(full, "utf8");
+        if (fs10.statSync(full).size > MAX_FILE_BYTES2) continue;
+        content = fs10.readFileSync(full, "utf8");
       } catch {
         continue;
       }
@@ -5525,8 +5774,8 @@ async function fetchLatestVersion() {
 }
 async function writeCache(data) {
   try {
-    await fs15.mkdir(CACHE_DIR, { recursive: true });
-    await fs15.writeFile(CACHE_FILE, JSON.stringify(data), "utf-8");
+    await fs17.mkdir(CACHE_DIR, { recursive: true });
+    await fs17.writeFile(CACHE_FILE, JSON.stringify(data), "utf-8");
   } catch {
   }
 }
@@ -5537,7 +5786,7 @@ function detectGlobalInstall(execPath = process.argv[1] || "", cwd = process.cwd
   if (!execPath) return null;
   let resolved = execPath;
   try {
-    resolved = fs8.realpathSync(execPath);
+    resolved = fs10.realpathSync(execPath);
   } catch {
   }
   const p = resolved.replace(/\\/g, "/");
@@ -7477,7 +7726,7 @@ function dispatch(argv, cwd) {
   }
   const looksLikeQuestion = /\s/.test(first) || first.endsWith("?");
   if (looksLikeQuestion) return ["ask", ...args];
-  if (fs8.existsSync(path.resolve(cwd, first))) {
+  if (fs10.existsSync(path.resolve(cwd, first))) {
     return [hasBuildOnlyFlag(args) ? "build" : "scan", ...args];
   }
   const moved = MOVED_COMMANDS[first];