@vibgrate/cli 2026.729.2 → 2026.730.1

package/dist/cli.js

@@ -1,48 +1,52 @@
 #!/usr/bin/env node
-import { sha256Hex, generateKeypair, dssePae, DSSE_PAYLOAD_TYPE, keyId, registerBuild, readGlobal, applyGlobalOptions, ProgressBar, printLogo, fetchCatalog, resolveProviders, runBuild } from './chunk-QDZ47G45.js';
-export { runBuild } from './chunk-QDZ47G45.js';
-import { CONTEXT_POLICY_VERSION, computeFcsReport, renderFcsReportMarkdown, createTrajectoryCollector, runAgent } from './chunk-2ZHWF7C6.js';
-import { loadAdvancedScanHook, baselineCommand } from './chunk-F6ZPUKED.js';
-import { runCodeSession } from './chunk-PRGCCW7D.js';
-import { summarizeDiffs, ScriptedProvider } from './chunk-RZEXHDCF.js';
+import { sha256Hex, generateKeypair, dssePae, DSSE_PAYLOAD_TYPE, keyId, registerBuild, readGlobal, applyGlobalOptions, ProgressBar, printLogo, fetchCatalog, resolveProviders, runBuild } from './chunk-EKCNSRNJ.js';
+export { runBuild } from './chunk-EKCNSRNJ.js';
+import { telemetryOptOut, StatsSharer, statsEndpoint, isCI } from './chunk-TJ3WIJ7H.js';
+import { loadAdvancedScanHook, baselineCommand } from './chunk-6WNJJXFY.js';
+import { buildModelInstallPlan } from './chunk-WHJMS7XC.js';
+import { runCodeSession } from './chunk-WBMMRERH.js';
 import { disableColor, info, c, json, out } from './chunk-CT5BS56U.js';
-import { VGD_PROTOCOL_VERSION, startVgdServer } from './chunk-74ZMAOVF.js';
+import { VGD_PROTOCOL_VERSION, startVgdServer } from './chunk-CQDCZQFV.js';
 import './chunk-5I4VSBWQ.js';
 import './chunk-IS7VTH2Q.js';
 import { init_resolve_ollama, gatherSystemMemory, resolveOllamaBinary, hasOllamaBinary, resolve_ollama_exports } from './chunk-OWSFZQOP.js';
 import { readOrchestratorState, writeOrchestratorState, parseMode, setDefaultMode, recommendMode, activePin, resolveMode, providerForBackend, QUALIFIED_PACKS, pinPack, unpinPack, buildOrchestratorStatus } from './chunk-NZELMYT4.js';
 import { fmt, estimateModelBytes } from './chunk-7N4Y3E47.js';
 import './chunk-IZDH67DX.js';
-import './chunk-TCJTQGAO.js';
-import { vgdIsRunning, vgdRequest, vgdSocketPath } from './chunk-PMYWZRRS.js';
-import { defaultProcessEndpoint, startProcessHostServer, resolveInferenceIsolation } from './chunk-SIPGDJT4.js';
-import { clearHostSessionPool, acquireHostSession, generateOnSession, listHostSessions, hostSessionPoolSize } from './chunk-6HX47EBL.js';
-import { buildIdentifierTrieFromGraph } from './chunk-JIBOJTGS.js';
-import './chunk-7AVYKZEM.js';
-import { buildModelInstallPlan } from './chunk-WHJMS7XC.js';
+import { defaultProcessEndpoint, startProcessHostServer, resolveInferenceIsolation } from './chunk-EVLS2M5G.js';
+import { clearHostSessionPool, acquireHostSession, generateOnSession, listHostSessions, hostSessionPoolSize } from './chunk-X634FZVG.js';
+import { CONTEXT_POLICY_VERSION, computeFcsReport, renderFcsReportMarkdown, createTrajectoryCollector, runAgent } from './chunk-KGWEBM2J.js';
+import './chunk-543E6WDJ.js';
+import { summarizeDiffs, ScriptedProvider } from './chunk-MYM5VIJ4.js';
 import { ensurePackage, ensureUnavailableMessage } from './chunk-REIGWTTH.js';
-import { serveStdio, exportGraph, GraphSource, createServer, formatForExt } from './chunk-PXXVLX7K.js';
-import { CliError, ExitCode, refreshIfStale, driftCount, ASSISTANTS, detectAssistants, usageError, detectServeLaunch, installAssistant, writeNavigationConfig, uninstallAssistant, buildGraph, writeSnapshot, probeFreshness, discover, assistantById, SMALL_REPO_FILES, SKIP_DIRS, SKIP_FILES } from './chunk-CYC3ZI32.js';
-import { resolveDsn, resolveIngestHost, dashHostForIngestHost, availableRegionIds, createWorkspaceDsn, writeStoredCredentials, credentialsPath, findGitRoot, ensureGitignored, gitignoreEntryForCredentials, clearStoredCredentials, parseDsn as parseDsn$1, uploadScanArtifact, ingestHostForRegionId, dsnCommand, pushCommand, countTokens, shortestPath, pathDisconnect, testsToRun, detectRunner, coveringTests, FREE_PACK, readScanArtifact, publishPrivateLibrary, assessDocQuality, symbolsFromApi, fetchHostedDocsCached, selectForBudget, hostedBase, readStoredCredentials, projectCredentialsPath, homeCredentialsPath } from './chunk-67YG3R5F.js';
+import './chunk-RGEVBSLK.js';
+import { vgdSocketPath, vgdIsRunning, vgdRequest, vgdPidPath } from './chunk-RBIRXQR6.js';
+import { buildIdentifierTrieFromGraph } from './chunk-5HYCB55P.js';
+import './chunk-7AVYKZEM.js';
+import { serveStdio, exportGraph, GraphSource, createServer, formatForExt } from './chunk-CFL3QQQZ.js';
+import { CliError, ExitCode, refreshIfStale, driftCount, ASSISTANTS, detectAssistants, usageError, detectServeLaunch, installAssistant, writeNavigationConfig, uninstallAssistant, buildGraph, writeSnapshot, probeFreshness, discover, assistantById, SMALL_REPO_FILES, SKIP_DIRS, SKIP_FILES } from './chunk-GLT3N7T2.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-6D4BCGRQ.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 } from './chunk-ON7PZNYV.js';
+import { ensureDir, pathExists, readJsonFile, writeTextFile, writeJsonFile } from './chunk-CRAMOEBE.js';
 import './chunk-IPICO2RV.js';
-import { inventory, enrichOnline, ECOSYSTEMS, catalogPath, libDir, loadCatalog, driftFor, addLibrary, resolveLib, libId, resolveVersion, readDoc, localPackageDocs, localApiSurface } from './chunk-G4HTI4ZM.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 } from './chunk-HDQG3QYV.js';
+import { inventory, enrichOnline, ECOSYSTEMS, catalogPath, libDir, loadCatalog, driftFor, addLibrary, resolveLib, libId, resolveVersion, readDoc, localPackageDocs, localApiSurface } from './chunk-FHJBGPJZ.js';
 import { recordCliCall, CLI_TOOL_ALIASES, savingsLedgerPath, clearSavings, readSavings, readUsage, readModelSavings, CAPSULE_RANKING_VERSION, SAVINGS_TOOLS, sanitizeClient } from './chunk-US2DAKCM.js';
-import { ensureDir, pathExists, readJsonFile, writeTextFile, writeJsonFile } from './chunk-CRAMOEBE.js';
+import { init_cli_invocation, resolveCliInvocation, NPX_INVOCATION } from './chunk-3LSG7Z4I.js';
 import { resolveOne } from './chunk-J7LKEB2R.js';
 import { embeddingsCached, resolveEmbedModel, loadEmbedder, getNodeEmbeddings, queryGraphSemantic, queryGraph, unavailableMessage, countPending, indexFor, impactOf, modelCacheInfo, clearModelCache } from './chunk-EETK7S43.js';
 import { discoverModels } from './chunk-CQDUBAQY.js';
-import { init_cli_invocation, resolveCliInvocation, NPX_INVOCATION } from './chunk-3LSG7Z4I.js';
 import { freeBytesOnVolume, weightStoreDir, listCachedWeights, ensureWeightCached, catalogIntegrityReport } from './chunk-OV4KGXPD.js';
 import { resolvedGrammarFiles, grammarSetVersion } from './chunk-UTNNGKKX.js';
 import './chunk-RXP66R2E.js';
-import { resolveGraphPath, renderReport, loadGraph, loadGraphFileWithSnapshot, writeArtifacts, vibgrateDir, mapFileExists, SCHEMA_VERSION } from './chunk-P3QIO4ZU.js';
-import { VERSION } from './chunk-WQE4OIZS.js';
+import { loadGraph, SCHEMA_VERSION } from './chunk-VOEYUAER.js';
+import { resolveGraphPath, renderReport, loadGraphFileWithSnapshot, writeArtifacts, vibgrateDir, mapFileExists, ensureVibgrateGitignore } from './chunk-5G7C6H2G.js';
+import { VERSION } from './chunk-Q4UQ73NA.js';
 import { cacheDir, serializeGraph, stableStringify } from './chunk-ZKNB4YH4.js';
 import './chunk-BWPBB45M.js';
 import { canonicalize, hashString, hashBytes } from './chunk-JFGYT6BI.js';
 import './chunk-BPF3YX2U.js';
-import { pathExists as pathExists$1, parseExcludePatterns } from './chunk-GI6W53LM.js';
+import { pathExists as pathExists$1, parseExcludePatterns } from './chunk-IDAQV3NQ.js';
 import { __toCommonJS } from './chunk-Z6ZWNWWR.js';
 import * as fs7 from 'fs';
 import fs7__default, { realpathSync } from 'fs';
@@ -50,15 +54,15 @@ import * as path37 from 'path';
 import path37__default from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { Command, CommanderError, Option } from 'commander';
-import * as os from 'os';
-import * as crypto3 from 'crypto';
-import { randomUUID } from 'crypto';
 import * as semver3 from 'semver';
 import semver3__default from 'semver';
 import { execSync, spawn, spawnSync, execFileSync } from 'child_process';
 import * as readline from 'readline';
+import * as crypto3 from 'crypto';
+import { randomUUID } from 'crypto';
 import chalk7 from 'chalk';
-import * as fs20 from 'fs/promises';
+import * as fs21 from 'fs/promises';
+import * as os from 'os';
 
 init_cli_invocation();
 function registerStatus(program) {
@@ -837,210 +841,6 @@ function fmtRef(r) {
 function pad2(s, n) {
   return s.padStart(n, " ");
 }
-var SCHEMA_VERSION2 = "1";
-var OFFSET_FILE = "stats-share.json";
-var INSTALL_ID_DIR = path37.join(os.homedir(), ".vibgrate");
-var INSTALL_ID_FILE = path37.join(INSTALL_ID_DIR, "install-id");
-var SEND_TIMEOUT_MS = 4e3;
-function telemetryOptOut(env = process.env) {
-  const dnt = (env.DO_NOT_TRACK ?? "").trim().toLowerCase();
-  if (dnt !== "" && dnt !== "0" && dnt !== "false") return "DO_NOT_TRACK";
-  const vt = (env.VIBGRATE_TELEMETRY ?? "").trim().toLowerCase();
-  if (vt === "0" || vt === "false" || vt === "off") return "VIBGRATE_TELEMETRY";
-  return null;
-}
-var CI_ENV_VARS = [
-  "CI",
-  "GITHUB_ACTIONS",
-  "GITLAB_CI",
-  "CIRCLECI",
-  "TRAVIS",
-  "BUILDKITE",
-  "JENKINS_URL",
-  "TF_BUILD"
-];
-function isCI(env = process.env) {
-  return CI_ENV_VARS.some((v) => {
-    const val = (env[v] ?? "").trim().toLowerCase();
-    return val !== "" && val !== "0" && val !== "false";
-  });
-}
-function installId(env = process.env) {
-  if (telemetryOptOut(env) !== null || isCI(env)) return randomUuid();
-  try {
-    const existing = fs7.readFileSync(INSTALL_ID_FILE, "utf8").trim();
-    if (isUuid(existing)) return existing;
-  } catch {
-  }
-  const id = randomUuid();
-  try {
-    fs7.mkdirSync(INSTALL_ID_DIR, { recursive: true });
-    fs7.writeFileSync(INSTALL_ID_FILE, id + "\n", { mode: 384 });
-  } catch {
-  }
-  return id;
-}
-function isUuid(s) {
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(s);
-}
-function randomUuid() {
-  return randomUUID();
-}
-function statsEndpoint() {
-  const override = process.env.VIBGRATE_STATS_ENDPOINT;
-  if (override && /^https?:\/\//.test(override)) return override;
-  return `https://${resolveIngestHost()}/v1/ingest/cli-mcp-usage`;
-}
-function offsetPath(root2) {
-  return path37.join(cacheDir(root2), OFFSET_FILE);
-}
-function ledgerFilePath(root2) {
-  return path37.join(cacheDir(root2), "savings.jsonl");
-}
-function readOffset(root2) {
-  try {
-    const raw = JSON.parse(fs7.readFileSync(offsetPath(root2), "utf8"));
-    return typeof raw.offset === "number" && raw.offset >= 0 ? raw.offset : 0;
-  } catch {
-    return 0;
-  }
-}
-function writeOffset(root2, offset) {
-  try {
-    fs7.mkdirSync(cacheDir(root2), { recursive: true });
-    fs7.writeFileSync(offsetPath(root2), JSON.stringify({ offset }) + "\n");
-  } catch {
-  }
-}
-function buildBatch(root2, fromOffset, id = installId()) {
-  const file = ledgerFilePath(root2);
-  let size = 0;
-  try {
-    size = fs7.statSync(file).size;
-  } catch {
-    return { batch: null, newOffset: 0 };
-  }
-  const start = fromOffset > size ? 0 : fromOffset;
-  if (start >= size) return { batch: null, newOffset: size };
-  let text = "";
-  try {
-    const fd = fs7.openSync(file, "r");
-    try {
-      const buf = Buffer.alloc(size - start);
-      fs7.readSync(fd, buf, 0, buf.length, start);
-      text = buf.toString("utf8");
-    } finally {
-      fs7.closeSync(fd);
-    }
-  } catch {
-    return { batch: null, newOffset: fromOffset };
-  }
-  const lastNl = text.lastIndexOf("\n");
-  if (lastNl < 0) return { batch: null, newOffset: start };
-  const consumed = start + lastNl + 1;
-  const rows = /* @__PURE__ */ new Map();
-  let total = 0;
-  let minTs = Infinity;
-  let maxTs = -Infinity;
-  for (const line of text.slice(0, lastNl).split("\n")) {
-    if (!line.trim()) continue;
-    let e;
-    try {
-      e = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    const source = e.source ?? "mcp";
-    const client = e.client ?? "unknown";
-    const outcome = e.outcome ?? "complete";
-    const key2 = `${source}|${client}|${e.tool}|${outcome}`;
-    const row = rows.get(key2) ?? {
-      source,
-      client,
-      tool: e.tool,
-      outcome,
-      calls: 0,
-      vgTokens: 0,
-      baselineTokens: 0
-    };
-    row.calls++;
-    row.vgTokens += e.vgTokens ?? 0;
-    row.baselineTokens += e.baselineTokens ?? 0;
-    rows.set(key2, row);
-    total++;
-    if (typeof e.ts === "number") {
-      if (e.ts < minTs) minTs = e.ts;
-      if (e.ts > maxTs) maxTs = e.ts;
-    }
-  }
-  if (total === 0 || !Number.isFinite(minTs)) return { batch: null, newOffset: consumed };
-  const batch = {
-    schemaVersion: SCHEMA_VERSION2,
-    installId: id,
-    vgVersion: VERSION,
-    os: process.platform,
-    arch: process.arch,
-    windowStart: new Date(minTs).toISOString(),
-    windowEnd: new Date(maxTs).toISOString(),
-    totalCalls: total,
-    rows: [...rows.values()]
-  };
-  return { batch, newOffset: consumed };
-}
-async function postBatch(batch) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), SEND_TIMEOUT_MS);
-  timer.unref?.();
-  try {
-    const res = await fetch(statsEndpoint(), {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Connection: "close" },
-      body: JSON.stringify(batch),
-      signal: controller.signal
-    });
-    return res.ok;
-  } catch {
-    return false;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-var StatsSharer = class {
-  constructor(root2) {
-    this.root = root2;
-    this.offset = readOffset(root2);
-  }
-  root;
-  id = installId();
-  offset;
-  flushing = false;
-  /**
-   * Flush any new ledger entries. Single-flight (a slow POST won't overlap the
-   * next tick). Best-effort: any failure is swallowed and retried next time.
-   */
-  async flush() {
-    if (this.flushing) return;
-    this.flushing = true;
-    try {
-      const { batch, newOffset } = buildBatch(this.root, this.offset, this.id);
-      if (!batch) {
-        if (newOffset > this.offset) {
-          this.offset = newOffset;
-          writeOffset(this.root, newOffset);
-        }
-        return;
-      }
-      const ok = await postBatch(batch);
-      if (ok) {
-        this.offset = newOffset;
-        writeOffset(this.root, newOffset);
-      }
-    } catch {
-    } finally {
-      this.flushing = false;
-    }
-  }
-};
 
 // src/util/origin.ts
 function originAllowed(origin, allowlist) {
@@ -1956,6 +1756,67 @@ function writeScanCache(root2, key2, artifact) {
   } catch {
   }
 }
+var MAX_ENTRIES = 1e3;
+var KEEP_ENTRIES = 500;
+function historyPath(root2) {
+  return path37.join(root2, ".vibgrate", "score-history.jsonl");
+}
+function parseLine(line) {
+  try {
+    const e = JSON.parse(line);
+    if (typeof e.ts === "string" && typeof e.score === "number" && typeof e.band === "string" && (e.mode === "verified" || e.mode === "estimated") && typeof e.methodology === "string") {
+      return e;
+    }
+  } catch {
+  }
+  return null;
+}
+function readHistory(root2) {
+  try {
+    return fs7.readFileSync(historyPath(root2), "utf8").split("\n").filter((l) => l.trim()).map(parseLine).filter((e) => e !== null);
+  } catch {
+    return [];
+  }
+}
+function lastEntry(root2) {
+  const all = readHistory(root2);
+  return all.length ? all[all.length - 1] : null;
+}
+function recentHistory(root2, days, now = Date.now()) {
+  const cutoff = now - days * 24 * 60 * 60 * 1e3;
+  return readHistory(root2).filter((e) => {
+    const t = Date.parse(e.ts);
+    return Number.isFinite(t) && t >= cutoff;
+  });
+}
+function recordScore(root2, entry) {
+  try {
+    const prev = lastEntry(root2);
+    if (prev && prev.score === entry.score && prev.band === entry.band && prev.mode === entry.mode && prev.methodology === entry.methodology) {
+      const prevT = Date.parse(prev.ts);
+      const nextT = Date.parse(entry.ts);
+      if (Number.isFinite(prevT) && Number.isFinite(nextT) && nextT - prevT < 24 * 60 * 60 * 1e3) {
+        return;
+      }
+    }
+    const file = historyPath(root2);
+    fs7.mkdirSync(path37.dirname(file), { recursive: true });
+    ensureVibgrateGitignore(root2);
+    fs7.appendFileSync(file, `${JSON.stringify(entry)}
+`);
+    const all = readHistory(root2);
+    if (all.length > MAX_ENTRIES) {
+      const kept = all.slice(-KEEP_ENTRIES);
+      fs7.writeFileSync(file, kept.map((e) => JSON.stringify(e)).join("\n") + "\n");
+    }
+  } catch {
+  }
+}
+function deltaFrom(prev, current) {
+  if (!prev) return void 0;
+  if (prev.methodology !== current.methodology) return void 0;
+  return current.score - prev.score;
+}
 
 // src/lsp/graph-query.ts
 async function runGraphQuery(graph, params, ctx) {
@@ -2408,6 +2269,12 @@ var VibgrateLanguageServer = class {
   artifact = null;
   scanning = false;
   queued = false;
+  /**
+   * Sticky until the next `scan()` runs: set by explicit "Rescan Workspace"
+   * (and preserved if a non-force schedule races the debounce). Bypasses the
+   * LSP scan cache so config/SKIP_DIRS changes actually re-score.
+   */
+  forceNextScan = false;
   debounce = null;
   shuttingDown = false;
   graph = null;
@@ -2467,12 +2334,17 @@ var VibgrateLanguageServer = class {
     this.conn.onRequest("textDocument/codeLens", (_m, params) => this.onCodeLens(params));
     this.conn.onRequest("vibgrate/graph/query", (_m, params) => this.onGraphQuery(params));
     this.conn.onRequest("vibgrate/score/forFile", (_m, params) => this.onScoreForFile(params));
+    this.conn.onRequest("vibgrate/score/history", (_m, params) => {
+      const p = params;
+      const days = typeof p?.days === "number" && p.days > 0 && p.days <= 365 ? p.days : 90;
+      return { days, entries: recentHistory(this.opts.root, days) };
+    });
     this.conn.onRequest("vibgrate/enrich", (_m, params) => this.onEnrich(params));
     this.conn.onRequest("vibgrate/vulns", (_m, _params) => this.onVulns());
     this.conn.onRequest("workspace/executeCommand", (_m, params) => {
       const p = params;
       if (p.command === "vibgrate.rescan") {
-        this.scheduleScan(0);
+        this.scheduleScan(0, { force: true });
         return { ok: true };
       }
       return null;
@@ -2487,7 +2359,8 @@ var VibgrateLanguageServer = class {
     });
   }
   // ── Scanning ─────────────────────────────────────────────────────────────
-  scheduleScan(delayMs) {
+  scheduleScan(delayMs, opts) {
+    if (opts?.force) this.forceNextScan = true;
     if (this.debounce) clearTimeout(this.debounce);
     this.debounce = setTimeout(() => void this.scan(), delayMs);
   }
@@ -2497,11 +2370,13 @@ var VibgrateLanguageServer = class {
       return;
     }
     this.scanning = true;
+    const force = this.forceNextScan;
+    this.forceNextScan = false;
     try {
       const cacheKey = { manifestHash: manifestHash(this.opts.root), toolVersion: VERSION, offline: this.opts.offline };
-      const cached = loadScanCache(this.opts.root, cacheKey);
+      const cached = force ? null : loadScanCache(this.opts.root, cacheKey);
       if (cached) {
-        this.artifact = cached.artifact;
+        this.artifact = pruneArtifactProjects(cached.artifact);
       } else {
         const scanOpts = {
           format: "json",
@@ -2516,7 +2391,7 @@ var VibgrateLanguageServer = class {
           vibgrateVersion: VERSION
         };
         const advanced = await loadAdvancedScanHook();
-        this.artifact = await runCoreScan(this.opts.root, scanOpts, advanced);
+        this.artifact = pruneArtifactProjects(await runCoreScan(this.opts.root, scanOpts, advanced));
         writeScanCache(this.opts.root, cacheKey, this.artifact);
       }
       this.publishScore();
@@ -2555,6 +2430,15 @@ var VibgrateLanguageServer = class {
       (f) => f.ruleId === "vibgrate/unmaintained" || f.ruleId === "vibgrate/abandoned"
     ).length;
     const band = a.drift.riskLevel ?? "low";
+    const historyEntry = {
+      ts: a.timestamp,
+      score: a.drift.score,
+      band,
+      mode: a.drift.mode ?? (hasReleaseDates(a) ? "verified" : "estimated"),
+      methodology: a.drift.methodologyVersion ?? "unknown"
+    };
+    const delta = deltaFrom(lastEntry(this.opts.root), historyEntry);
+    recordScore(this.opts.root, historyEntry);
     const payload = {
       score: a.drift.score,
       band,
@@ -2562,13 +2446,15 @@ var VibgrateLanguageServer = class {
       // offline marker. An air-gapped scan against a dated snapshot is Verified.
       // The score now carries the authoritative provenance (driftscore-3.0
       // envelope); fall back to the artifact heuristic for pre-v3 engines.
-      mode: a.drift.mode ?? (hasReleaseDates(a) ? "verified" : "estimated"),
-      methodology: a.drift.methodologyVersion ?? "unknown",
+      mode: historyEntry.mode,
+      methodology: historyEntry.methodology,
       scale: "0 best, 100 worst",
       counts: { behind, eol, unmaintained, total },
       rootPath: a.rootPath,
       scannedAt: a.timestamp,
-      ...buildBreakdown(a.drift, a.projects ?? []) ? { breakdown: buildBreakdown(a.drift, a.projects ?? []) } : {}
+      ...delta !== void 0 ? { delta } : {},
+      ...buildBreakdown(a.drift, a.projects ?? []) ? { breakdown: buildBreakdown(a.drift, a.projects ?? []) } : {},
+      ...buildEolHorizon(a.projects ?? []) ? { eolHorizon: buildEolHorizon(a.projects ?? []) } : {}
     };
     this.conn.notify("vibgrate/score", payload);
   }
@@ -2754,6 +2640,9 @@ var VibgrateLanguageServer = class {
     const reachedPkgs = packageReachSet(this.graph);
     const targets = [];
     for (const proj of a.projects ?? []) {
+      if (isPrunedWorkspacePath(proj.path) || isPrunedWorkspacePath(manifestRelativePath(proj))) {
+        continue;
+      }
       const ecosystem = osvEcosystem(proj.type);
       if (!ecosystem) continue;
       const relManifest = manifestRelativePath(proj);
@@ -2805,6 +2694,24 @@ function uriToPath(uri) {
     return uri;
   }
 }
+function isPrunedWorkspacePath(relPath) {
+  if (!relPath || relPath === "." || relPath === "") return false;
+  const parts = relPath.split(/[/\\]/).filter(Boolean);
+  if (parts.includes(".claude")) return true;
+  return parts.some((p) => SKIP_DIRS.has(p));
+}
+function pruneArtifactProjects(a) {
+  const projects = (a.projects ?? []).filter(
+    (p) => !isPrunedWorkspacePath(p.path) && !isPrunedWorkspacePath(manifestRelativePath(p))
+  );
+  if (projects.length === (a.projects ?? []).length) {
+    const findings2 = (a.findings ?? []).filter((f) => !isPrunedWorkspacePath(f.location));
+    if (findings2.length === (a.findings ?? []).length) return a;
+    return { ...a, findings: findings2 };
+  }
+  const findings = (a.findings ?? []).filter((f) => !isPrunedWorkspacePath(f.location));
+  return { ...a, projects, findings };
+}
 function projectForFile(root2, a, filePath) {
   const dir = path37.dirname(path37.resolve(filePath));
   let best;
@@ -2852,9 +2759,31 @@ function scoreForProject(a, proj) {
     counts: { behind, eol, unmaintained, total },
     rootPath: proj.path,
     scannedAt: a.timestamp,
-    ...buildBreakdown(proj.drift, [proj]) ? { breakdown: buildBreakdown(proj.drift, [proj]) } : {}
+    ...buildBreakdown(proj.drift, [proj]) ? { breakdown: buildBreakdown(proj.drift, [proj]) } : {},
+    ...buildEolHorizon([proj]) ? { eolHorizon: buildEolHorizon([proj]) } : {}
   };
 }
+function runtimeHorizonLabel(project) {
+  const kind = project.type === "node" ? "Node.js" : project.type === "dotnet" ? ".NET" : project.type === "python" ? "Python" : project.type === "java" ? "Java" : project.type;
+  return project.runtime ? `${kind} ${project.runtime}` : kind;
+}
+function buildEolHorizon(projects, now = Date.now()) {
+  const byLabel = /* @__PURE__ */ new Map();
+  for (const p of projects) {
+    if (!p.runtimeEolDate) continue;
+    const t = Date.parse(p.runtimeEolDate);
+    if (!Number.isFinite(t)) continue;
+    const label = runtimeHorizonLabel(p);
+    if (byLabel.has(label)) continue;
+    byLabel.set(label, {
+      runtime: label,
+      eolDate: p.runtimeEolDate,
+      daysUntil: Math.round((t - now) / (24 * 60 * 60 * 1e3))
+    });
+  }
+  if (byLabel.size === 0) return void 0;
+  return [...byLabel.values()].sort((a, b) => a.daysUntil - b.daysUntil).slice(0, 5);
+}
 function bandForScore(n) {
   if (n <= 30) return "low";
   if (n <= 60) return "moderate";
@@ -6122,7 +6051,7 @@ function discoverMcpServers(root2, ownServers) {
 
 // src/commands/code.ts
 function registerCode(program) {
-  const cmd = program.command("code").description("propose a graph-grounded code edit (guided mode with no instruction; dry-run by default)").argument("[instruction...]", "what to change, in plain language (omit for guided interactive mode)").option("--provider <id>", "backend: ollama, lmstudio, foundry-local, openrouter, litellm, openai, together, llama-cpp").option("--model <id>", "model id (or set VG_CODE_MODEL). No model is hard-coded \u2014 pick the current best.").option("--mode <mode>", "Code Mode: spark | flow | forge (preferred over raw model names; auto-fits when omitted and no --model)").option("--model-path <gguf>", "gguf path for --provider llama-cpp (weights are never auto-downloaded)").option("-f, --file <path>", "restrict the edit surface to this file (repeatable)", collect, []).option("-b, --budget <n>", "approx context token budget", "3000").option("--apply", "write the change (still requires --yes or an interactive confirm)").option("--yes", "consent to write / to a first-use package install, non-interactively").option("--auto", "autonomous agent: auto-approve every edit and command (use with care)").option("--max-steps <n>", "cap the number of agent steps", "24").option("--single", "one-shot planner (single edit) instead of the multi-step agent").option("--stream", "stream the model output live").option("--stream-json", "machine protocol: NDJSON agent events on stdout, approval decisions on stdin (for host UIs like the VS Code panel)").option("--verify [command]", "after the agent finishes, run tests and make it fix failures (uses the config testCommand if no command is given)").option("--continue", "resume the most recent session (recap + restore /undo)").option("--capsule", "use a source-bearing Task Capsule for first context (Fusion A/B; exact source ranges from the graph)").option("--no-capsule", "disable Task Capsule context even if enabled in .vibgrate/code.json").option("--security-tier <tier>", "shell isolation: L0 (host), L1 (Seatbelt/bubblewrap when available), L2/L3 reserved").option("--mock <file>", "use a scripted reply from <file> instead of a model (offline; for tests/CI)").option("-o, --out <file>", "write the JSON result to <file> (implies --json shape; for CI/benchmarks)").action(async function(instructionParts, opts) {
+  const cmd = program.command("code").description("propose a graph-grounded code edit (guided mode with no instruction; dry-run by default)").argument("[instruction...]", "what to change, in plain language (omit for guided interactive mode)").option("--provider <id>", "backend: vibgrate-relay (Vibgrate Relay), ollama, lmstudio, foundry-local, openrouter, litellm, openai, together, llama-cpp").option("--model <id>", "model id (or set VG_CODE_MODEL). No model is hard-coded \u2014 pick the current best.").option("--mode <mode>", "Code Mode: spark | flow | forge (preferred over raw model names; auto-fits when omitted and no --model)").option("--model-path <gguf>", "gguf path for --provider llama-cpp (weights are never auto-downloaded)").option("-f, --file <path>", "restrict the edit surface to this file (repeatable)", collect, []).option("-b, --budget <n>", "approx context token budget", "3000").option("--apply", "write the change (still requires --yes or an interactive confirm)").option("--yes", "consent to write / to a first-use package install, non-interactively").option("--auto", "autonomous agent: auto-approve every edit and command (use with care)").option("--max-steps <n>", "cap the number of agent steps", "24").option("--single", "one-shot planner (single edit) instead of the multi-step agent").option("--stream", "stream the model output live").option("--stream-json", "machine protocol: NDJSON agent events on stdout, approval decisions on stdin (for host UIs like the VS Code panel)").option("--session", "with --stream-json: stay open for further turns (warm graph and tools) instead of exiting after one").option("--verify [command]", "after the agent finishes, run tests and make it fix failures (uses the config testCommand if no command is given)").option("--continue", "resume the most recent session (recap + restore /undo)").option("--capsule", "use a source-bearing Task Capsule for first context (Fusion A/B; exact source ranges from the graph)").option("--no-capsule", "disable Task Capsule context even if enabled in .vibgrate/code.json").option("--security-tier <tier>", "shell isolation: L0 (host), L1 (Seatbelt/bubblewrap when available), L2/L3 reserved").option("--mock <file>", "use a scripted reply from <file> instead of a model (offline; for tests/CI)").option("-o, --out <file>", "write the JSON result to <file> (implies --json shape; for CI/benchmarks)").action(async function(instructionParts, opts) {
     const global = readGlobal(this);
     const instruction = (instructionParts ?? []).join(" ").trim();
     const config = loadCodeConfig(rootOf(global));
@@ -6135,7 +6064,7 @@ function registerCode(program) {
       try {
         const { parseMode: parseMode2, resolveMode: resolveMode2, readOrchestratorState: readOrchestratorState2, activePin: activePin2 } = await import('./model-orchestrator-LHYPJBFH.js');
         const { gatherSystemMemory: gatherSystemMemory2 } = await import('./local-runtime-2ED33KK6.js');
-        const { loadGraph: loadGraph2 } = await import('./load-4MLIHGXF.js');
+        const { loadGraph: loadGraph2 } = await import('./load-YPSEDYIW.js');
         const state = readOrchestratorState2();
         const mode = parseMode2(modeFlag) ?? state.defaultMode ?? void 0;
         const pin = mode ? activePin2(mode, state) : null;
@@ -6219,7 +6148,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-HLGJJFLI.js');
+      const { runInteractive } = await import('./interactive-NJG6467J.js');
       await runInteractive(
         rootOf(global),
         global,
@@ -6300,19 +6229,20 @@ function registerCode(program) {
         process.stdout.write(JSON.stringify(line) + "\n");
       };
       try {
+        const { RunOutcomeRecorder, newOneShotRunId, turnRunId } = await import('./run-outcome-5FQWHWYK.js');
         const primarySlug = route.providers[0]?.model.includes("/") ? route.providers[0].model.split("/")[0] : route.providers[0]?.id;
-        const { runCodeStreamJson } = await import('./stream-json-Y45JBNYP.js');
-        const { nodeCodeFs } = await import('./session-2JT4AUZT.js');
+        const { runCodeStreamJson, parseHostMessage } = await import('./stream-json-3YOPU3LF.js');
+        const { nodeCodeFs } = await import('./session-3OBIQLE4.js');
         const readline5 = 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-5M6QZZOS.js');
-        const { resolveGraphBackend } = await import('./graph-backend-GBL33GMW.js');
+        const { startCodeRuntimeSession } = await import('./runtime-session-Y4ZD3QDO.js');
+        const { resolveGraphBackend } = await import('./graph-backend-G5Y6QQV4.js');
         const { detectGitRef } = await import('./git-ref-RSRAN4OH.js');
         const { repositoryIdFromRoot } = await import('./paths-62AKTFSR.js');
-        const { vgdRequest: vgdRequest2 } = await import('./vgd-TGGEAGQZ.js');
+        const { vgdRequest: vgdRequest2 } = await import('./vgd-DH7AHQ23.js');
         const federation = loadOrDiscoverFederation(root2);
         const modelProfile = mergeModelExecutionProfile(
           resolveModelExecutionProfile({
@@ -6329,6 +6259,18 @@ function registerCode(program) {
         const runtime = await startCodeRuntimeSession({ root: root2 });
         const git2 = detectGitRef(root2);
         const repositoryId = repositoryIdFromRoot(root2);
+        const runOutcome = new RunOutcomeRecorder(
+          root2,
+          repositoryId,
+          git2.ref || null,
+          { mode: codeModeActive ? modeFlag : void 0, provider: primarySlug, model: route.providers[0]?.model },
+          tier,
+          !!auto
+        );
+        const emitAndRecord = (line) => {
+          runOutcome.observe(line);
+          emitStream(line);
+        };
         if (runtime.socketPath && git2.ref) {
           try {
             await vgdRequest2(
@@ -6358,7 +6300,7 @@ ${res.stderr}` : ""),
             exitCode: res.status ?? 1
           };
         };
-        const { createVgBuiltinMcpTools, mergeExternalToolsets } = await import('./vg-mcp-bridge-ZCKBYQ2D.js');
+        const { createVgBuiltinMcpTools, mergeExternalToolsets } = await import('./vg-mcp-bridge-PZFGTZSA.js');
         const vgBuiltin = createVgBuiltinMcpTools({
           getGraph: () => graph,
           root: root2,
@@ -6378,50 +6320,204 @@ ${res.stderr}` : ""),
           };
         }
         const externalTools = mergeExternalToolsets(vgBuiltin, projectMcp);
+        const { createCheckpoint } = await import('./checkpoint-4WFZMKEO.js');
+        const os4 = await import('os');
+        const pathMod = await import('path');
+        const checkpointIndex = pathMod.join(
+          fs7.mkdtempSync(pathMod.join(os4.tmpdir(), "vg-code-cp-")),
+          "index"
+        );
+        const gitRunner = (gitArgs, gitEnv) => {
+          const res = child.spawnSync("git", gitArgs, {
+            cwd: root2,
+            encoding: "utf8",
+            env: { ...process.env, ...gitEnv ?? {} },
+            timeout: 3e4,
+            maxBuffer: 32 * 1024 * 1024
+          });
+          return { stdout: res.stdout ?? "", exitCode: res.status ?? 1 };
+        };
+        const checkpointSessionId = `r${Date.now().toString(36)}`;
+        let checkpointSeq = 0;
+        const takeCheckpoint = (files) => createCheckpoint(gitRunner, {
+          sessionId: checkpointSessionId,
+          seq: ++checkpointSeq,
+          files,
+          indexFile: checkpointIndex
+        });
+        const { loadProjectRules, nodeRulesReader } = await import('./rules-ASYEUNB5.js');
+        const projectRules = loadProjectRules(nodeRulesReader(root2));
+        if (projectRules.sources.length && !global.quiet) {
+          emitStream({
+            event: "event",
+            type: "notice",
+            text: `project instructions: ${projectRules.sources.join(", ")}`
+          });
+        }
+        const baseAgentOptions = {
+          graph,
+          root: root2,
+          providers: route.providers,
+          fsImpl: nodeCodeFs(root2),
+          run,
+          executionEnv,
+          graphBackend,
+          modelProfile,
+          auto: !!auto,
+          maxSteps,
+          budget: modelProfile.capsuleBudgetTokens,
+          contextBudget,
+          denyCommands: config.denyCommands,
+          testCommand: config.testCommand,
+          stream: true,
+          verify: verify3 ? { command: verify3.command, maxRounds: modelProfile.maxRepairRounds } : void 0,
+          capsule,
+          files: opts.file.length ? opts.file : void 0,
+          worktreeOverlay: true,
+          advancedMode: !capsule,
+          externalTools,
+          attribution: {
+            client: "vg-code",
+            provider: primarySlug,
+            model: route.providers[0]?.model
+          },
+          now: () => Date.now(),
+          projectRules: projectRules.rendered || void 0,
+          checkpoint: takeCheckpoint
+        };
         try {
-          await runCodeStreamJson({
-            graph,
-            root: root2,
-            instruction,
-            providers: route.providers,
-            fsImpl: nodeCodeFs(root2),
-            run,
-            executionEnv,
-            graphBackend,
-            modelProfile,
-            auto: !!auto,
-            maxSteps,
-            budget: modelProfile.capsuleBudgetTokens,
-            contextBudget,
-            denyCommands: config.denyCommands,
-            testCommand: config.testCommand,
-            stream: true,
-            verify: verify3 ? { command: verify3.command, maxRounds: modelProfile.maxRepairRounds } : void 0,
-            capsule,
-            files: opts.file.length ? opts.file : void 0,
-            worktreeOverlay: true,
-            advancedMode: !capsule,
-            externalTools,
-            attribution: {
-              client: "vg-code",
-              provider: primarySlug,
-              model: route.providers[0]?.model
-            },
-            now: () => Date.now(),
-            emit: emitStream,
-            bindDecisions: (session) => {
-              streamApprove = (action) => session.approve(action);
-              const rl = readline5.createInterface({ input: process.stdin });
-              rl.on("line", (raw) => {
-                try {
-                  const msg = JSON.parse(raw);
-                  if (typeof msg.approveId === "number") session.submitDecision(msg.approveId, !!msg.approve);
-                  if (typeof msg.answerId === "number") session.submitAnswer(msg.answerId, String(msg.answer ?? ""));
-                } catch {
-                }
+          if (opts.session) {
+            const { runCodeStreamJsonSession } = await import('./stream-json-3YOPU3LF.js');
+            const { runAgent: runAgent2 } = await import('./agent-33BMKWJC.js');
+            const {
+              loadLatestSession,
+              newSession,
+              recordTask,
+              saveSession,
+              summarizeSession
+            } = await import('./session-store-O4XPXKOV.js');
+            const resumedRecord = opts.continue ? loadLatestSession(root2) : void 0;
+            let record = resumedRecord ?? newSession(
+              `s${Date.now().toString(36)}`,
+              primarySlug ?? route.providers[0]?.id ?? "unknown",
+              route.providers[0]?.model ?? "unknown",
+              Date.now()
+            );
+            const pendingTurns = [];
+            let wakeTurn;
+            let ended = false;
+            const pushTurn = (instruction2) => {
+              if (wakeTurn) {
+                const wake = wakeTurn;
+                wakeTurn = void 0;
+                wake(instruction2);
+              } else if (instruction2 !== null) {
+                pendingTurns.push(instruction2);
+              }
+            };
+            const nextTurn = () => {
+              if (ended) return Promise.resolve(null);
+              const queued = pendingTurns.shift();
+              if (queued !== void 0) return Promise.resolve(queued);
+              return new Promise((resolve21) => {
+                wakeTurn = resolve21;
               });
-            }
-          });
+            };
+            let turnIndex = 0;
+            await runCodeStreamJsonSession({
+              emit: emitAndRecord,
+              auto: !!auto,
+              sessionId: record.id,
+              resumed: !!resumedRecord,
+              instruction,
+              nextTurn,
+              bindDecisions: (session) => {
+                streamApprove = (action) => session.approve(action);
+                const rl = readline5.createInterface({ input: process.stdin });
+                rl.on("line", (raw) => {
+                  const msg = parseHostMessage(raw);
+                  if (!msg) return;
+                  if (msg.kind === "approve") {
+                    session.submitDecision(msg.id, msg.approve);
+                    runOutcome.noteDecision(msg.id, msg.approve);
+                  } else if (msg.kind === "answer") session.submitAnswer(msg.id, msg.answer);
+                  else if (msg.kind === "submit") pushTurn(msg.instruction);
+                  else if (msg.kind === "restore") {
+                    void import('./checkpoint-4WFZMKEO.js').then(({ restoreCheckpoint }) => {
+                      const outcome = restoreCheckpoint(gitRunner, {
+                        commit: msg.commit,
+                        files: msg.files
+                      });
+                      emitStream({ event: "checkpoint-restored", commit: msg.commit, ...outcome });
+                    });
+                  } else if (msg.kind === "cancel") {
+                    session.cancelTurn();
+                    runOutcome.cancelPending();
+                  } else if (msg.kind === "end") {
+                    ended = true;
+                    pushTurn(null);
+                  }
+                });
+                rl.on("close", () => {
+                  ended = true;
+                  session.cancelTurn();
+                  runOutcome.cancelPending();
+                  pushTurn(null);
+                });
+              },
+              runTurn: ({ instruction: turnInstruction, priorSummary, signal, session }) => {
+                turnIndex++;
+                runOutcome.beginRun(turnRunId(record.id, turnIndex), turnInstruction);
+                return runAgent2({
+                  ...baseAgentOptions,
+                  instruction: turnInstruction,
+                  priorSummary,
+                  signal,
+                  approve: session.approve,
+                  askUser: session.askUser,
+                  onEvent: session.onEvent
+                });
+              },
+              onTurnEnd: (turn) => {
+                record = recordTask(
+                  record,
+                  {
+                    instruction: turn.instruction,
+                    summary: turn.result?.finalText ?? "turn failed",
+                    changes: turn.result?.changes ?? [],
+                    stopped: turn.result?.stopped ?? "error"
+                  },
+                  Date.now()
+                );
+                saveSession(root2, record);
+                return summarizeSession(record);
+              }
+            });
+          } else {
+            runOutcome.beginRun(newOneShotRunId(), instruction);
+            await runCodeStreamJson({
+              ...baseAgentOptions,
+              instruction,
+              emit: emitAndRecord,
+              bindDecisions: (session) => {
+                streamApprove = (action) => session.approve(action);
+                const rl = readline5.createInterface({ input: process.stdin });
+                rl.on("line", (raw) => {
+                  const msg = parseHostMessage(raw);
+                  if (!msg) return;
+                  if (msg.kind === "approve") {
+                    session.submitDecision(msg.id, msg.approve);
+                    runOutcome.noteDecision(msg.id, msg.approve);
+                  } else if (msg.kind === "answer") session.submitAnswer(msg.id, msg.answer);
+                  else if (msg.kind === "cancel") {
+                    session.cancelTurn();
+                    runOutcome.cancelPending();
+                  }
+                });
+                rl.on("close", () => runOutcome.cancelPending());
+              }
+            });
+          }
         } finally {
           await disposeMcpStream?.();
           await runtime.dispose();
@@ -6440,8 +6536,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-HLGJJFLI.js');
-      const { nodeCodeFs } = await import('./session-2JT4AUZT.js');
+      const { agentTask } = await import('./interactive-NJG6467J.js');
+      const { nodeCodeFs } = await import('./session-3OBIQLE4.js');
       const { TtyPrompter } = await import('./ui-K7D3BCHD.js');
       let priorSummary;
       if (opts.continue) {
@@ -6450,7 +6546,7 @@ ${res.stderr}` : ""),
         if (prev) priorSummary = summarizeSession(prev);
       }
       const prompter = tty ? new TtyPrompter() : void 0;
-      const { createVgBuiltinMcpTools, mergeExternalToolsets } = await import('./vg-mcp-bridge-ZCKBYQ2D.js');
+      const { createVgBuiltinMcpTools, mergeExternalToolsets } = await import('./vg-mcp-bridge-PZFGTZSA.js');
       const vgBuiltin = createVgBuiltinMcpTools({
         getGraph: () => graph,
         root: root2,
@@ -6474,11 +6570,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-5M6QZZOS.js');
-        const { resolveGraphBackend } = await import('./graph-backend-GBL33GMW.js');
+        const { startCodeRuntimeSession } = await import('./runtime-session-Y4ZD3QDO.js');
+        const { resolveGraphBackend } = await import('./graph-backend-G5Y6QQV4.js');
         const { detectGitRef } = await import('./git-ref-RSRAN4OH.js');
         const { repositoryIdFromRoot } = await import('./paths-62AKTFSR.js');
-        const { vgdRequest: vgdRequest2 } = await import('./vgd-TGGEAGQZ.js');
+        const { vgdRequest: vgdRequest2 } = await import('./vgd-DH7AHQ23.js');
         const federation = loadFederation(root2);
         const modelProfile = mergeModelExecutionProfile(
           resolveModelExecutionProfile({
@@ -7194,7 +7290,9 @@ function registerDaemon(program) {
     if (await vgdIsRunning({ socketPath })) {
       throw new CliError(`vgd is already running at ${socketPath}`, ExitCode.ERROR);
     }
-    const server = await startVgdServer({ socketPath });
+    let requestShutdown = () => {
+    };
+    const server = await startVgdServer({ socketPath, onShutdownRequest: () => requestShutdown() });
     if (!global.quiet) {
       info(`vgd \xB7 listening on ${c.dim(server.socketPath)} (${VGD_PROTOCOL_VERSION})`);
       info(c.dim("  register a workspace: vg daemon register"));
@@ -7205,6 +7303,7 @@ function registerDaemon(program) {
       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(() => {
@@ -7224,29 +7323,66 @@ function registerDaemon(program) {
       }
       return;
     }
-    const child = spawnDetachedDaemonStart(socketPath);
-    child.unref();
-    const deadline = Date.now() + 8e3;
-    let ready = false;
-    while (Date.now() < deadline) {
-      await sleep(100);
-      if (await vgdIsRunning({ socketPath })) {
-        ready = true;
-        break;
-      }
-    }
-    if (!ready) {
-      throw new CliError(`vgd failed to become ready at ${socketPath}`, ExitCode.ERROR);
-    }
+    const child = await startDetachedVgd(socketPath);
     const res = await vgdRequest({ op: "status" }, { socketPath });
     if (global.json) {
       json({ running: true, ensured: true, ...res.ok ? res : { socketPath } });
     } else if (!global.quiet) {
-      const pid = res.ok && "pid" in res ? res.pid : child.pid;
+      const pid = res.ok && "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);
@@ -7318,28 +7454,38 @@ function registerDaemon(program) {
     if (!await vgdIsRunning({ socketPath })) {
       throw new CliError(`vgd is not running \u2014 start it with \`vg daemon ensure\` (${socketPath})`, ExitCode.NOT_FOUND);
     }
-    const { loadGraph: loadGraph2 } = await import('./load-4MLIHGXF.js');
-    const { detectGitRef } = await import('./git-ref-RSRAN4OH.js');
-    const { repositoryIdFromRoot } = await import('./paths-62AKTFSR.js');
     const opts = this.opts();
-    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);
-    const put = await vgdRequest(
-      { op: "put-graph", repositoryId, gitRef: git2, graph },
+    const loaded = await vgdRequest(
+      { op: "load-graph", root: root2, gitRef: opts.gitRef?.trim() || void 0, graphPath: global.graph },
       { socketPath }
     );
-    if (!put.ok) throw new CliError(put.error, ExitCode.ERROR);
+    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-YPSEDYIW.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 ("stored" in 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}`));
     }
@@ -7457,6 +7603,62 @@ function spawnDetachedDaemonStart(socketPath) {
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
+async function startDetachedVgd(socketPath) {
+  const child = spawnDetachedDaemonStart(socketPath);
+  child.unref();
+  const deadline = Date.now() + 8e3;
+  while (Date.now() < deadline) {
+    await sleep(100);
+    if (await vgdIsRunning({ socketPath })) return child.pid;
+  }
+  throw new CliError(`vgd failed to become ready 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 = fs7.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 });
@@ -7667,7 +7869,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-UOTGTJYT.js');
+    const { runBaseline } = await import('./baseline-V6MYDEMS.js');
     await runBaseline(rootDir);
   }
   console.log("");
@@ -7777,9 +7979,9 @@ async function fileReferencesIdentifier(rootDir, relFile, identifier, readFile3)
 }
 async function defaultReadFile(absPath) {
   try {
-    const stat2 = await fs20.stat(absPath);
+    const stat2 = await fs21.stat(absPath);
     if (!stat2.isFile() || stat2.size > MAX_FILE_BYTES) return null;
-    return await fs20.readFile(absPath, "utf8");
+    return await fs21.readFile(absPath, "utf8");
   } catch {
     return null;
   }
@@ -8432,10 +8634,10 @@ function scanStaleness(rootDir, artifactPath) {
   }
   let newest = -Infinity;
   let newestChanged;
-  const MAX_ENTRIES = 2e4;
+  const MAX_ENTRIES2 = 2e4;
   let scanned = 0;
   const walk2 = (dir, depth) => {
-    if (depth > 8 || scanned > MAX_ENTRIES) return;
+    if (depth > 8 || scanned > MAX_ENTRIES2) return;
     let entries;
     try {
       entries = fs7.readdirSync(dir, { withFileTypes: true });
@@ -8444,7 +8646,7 @@ function scanStaleness(rootDir, artifactPath) {
     }
     for (const e of entries) {
       scanned++;
-      if (scanned > MAX_ENTRIES) break;
+      if (scanned > MAX_ENTRIES2) break;
       if (e.isDirectory()) {
         if (!SKIP_DIRS2.has(e.name) && !e.name.startsWith(".")) walk2(path37.join(dir, e.name), depth + 1);
         continue;
@@ -8977,8 +9179,8 @@ async function fetchLatestVersion() {
 }
 async function writeCache(data) {
   try {
-    await fs20.mkdir(CACHE_DIR, { recursive: true });
-    await fs20.writeFile(CACHE_FILE, JSON.stringify(data), "utf-8");
+    await fs21.mkdir(CACHE_DIR, { recursive: true });
+    await fs21.writeFile(CACHE_FILE, JSON.stringify(data), "utf-8");
   } catch {
   }
 }
@@ -9167,8 +9369,29 @@ var updateCommand = new Command("update").description("Update vibgrate to the la
       process.exit(1);
     }
     if (opts.reap !== false) reapAndReport(cwd, latest);
+    if (opts.reap !== false) await restartVgdAndReport();
   }
 );
+async function restartVgdAndReport() {
+  let result;
+  try {
+    result = await restartVgdIfRunning();
+  } catch {
+    return;
+  }
+  if (result === "not-running") return;
+  if (result === "restarted") {
+    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.")
+    );
+  } else {
+    console.log(
+      chalk7.dim('Could not restart the vgd daemon automatically \u2014 run "vg daemon restart" to pick up the update.')
+    );
+  }
+}
 function reapAndReport(cwd, keepVersion) {
   let reaped = [];
   try {