@codacy/verity-cli 0.32.5-experimental.4d91ca0 → 0.32.6

package/bin/verity.js

@@ -10523,7 +10523,7 @@ var SECURITY_PATTERNS = [
   /Dockerfile/
 ];
 var PROD_SERVICE_URL = "https://ofcamwrjwrkazqvdchko.supabase.co/functions/v1";
-var DEFAULT_SERVICE_URL = "https://wukeddyzpijoegyajtnc.supabase.co/functions/v1".length > 0 ? "https://wukeddyzpijoegyajtnc.supabase.co/functions/v1" : PROD_SERVICE_URL;
+var DEFAULT_SERVICE_URL = "".length > 0 ? "" : PROD_SERVICE_URL;
 var GITHUB_CLIENT_ID = "Iv23li88HxAi3ZrbYzWh";
 var GITHUB_DEVICE_CODE_URL = "https://github.com/login/device/code";
 var GITHUB_ACCESS_TOKEN_URL = "https://github.com/login/oauth/access_token";
@@ -14012,12 +14012,239 @@ async function retrieveForInjection(promptText, taskFiles = [], budgetTokens = D
 
 // src/lib/memory-sync.ts
 var import_promises8 = require("node:fs/promises");
-var import_node_fs12 = require("node:fs");
+var import_node_fs13 = require("node:fs");
 var import_node_path12 = require("node:path");
 var import_node_crypto3 = require("node:crypto");
 
-// src/lib/safe-path.ts
+// src/lib/gitignore.ts
+var import_node_child_process6 = require("node:child_process");
 var import_node_fs11 = require("node:fs");
+var VERITY_GITIGNORE_MARKER = "# Verity \u2014 machine-local state.";
+var SETTINGS_LOCAL_IGNORE_ENTRY = ".claude/settings.local.json";
+var VERITY_GITIGNORE_BLOCK = [
+  "# Verity \u2014 machine-local state. Everything in .verity/ is ignored except the",
+  "# shared standard, which is meant to be committed. The knowledge graph under",
+  "# .verity/memory/ is machine-local too: the service rebuilds it, and committing",
+  "# it puts generated notes in every diff and pull request.",
+  ".verity/*",
+  "!.verity/standard.yaml",
+  SETTINGS_LOCAL_IGNORE_ENTRY,
+  ""
+].join("\n");
+var MEMORY_OPT_OUT_MARKER = "# Verity: this project commits its knowledge graph on purpose.";
+var MEMORY_OPT_OUT_STANZA = [
+  MEMORY_OPT_OUT_MARKER,
+  '# Remove these three lines (or run "verity memory untrack") to stop tracking it.',
+  "!.verity/memory/",
+  ".verity/memory/log.md",
+  ""
+].join("\n");
+var BREAKING_ENTRIES = /* @__PURE__ */ new Set([".verity/", ".verity"]);
+var SUPERSEDED_COMMENT = "# shared standard and the knowledge graph, which are meant to be committed.";
+var MEMORY_COMMENT = [
+  "# shared standard, which is meant to be committed. The knowledge graph under",
+  "# .verity/memory/ is machine-local too: the service rebuilds it, and committing",
+  "# it puts generated notes in every diff and pull request."
+];
+var SUPERSEDED_MEMORY_LINES = /* @__PURE__ */ new Set([
+  "!.verity/memory/",
+  "!.verity/memory",
+  ".verity/memory/log.md",
+  SUPERSEDED_COMMENT
+]);
+function isIgnored(path) {
+  try {
+    (0, import_node_child_process6.execSync)(`git check-ignore -q -- "${path}"`, { stdio: "pipe" });
+    return true;
+  } catch (err) {
+    return err.status === 1 ? false : null;
+  }
+}
+function semanticsHold() {
+  const snapshot = isIgnored(".verity/.snapshot/__probe__");
+  const standard = isIgnored(".verity/standard.yaml");
+  const futureState = isIgnored(".verity/.__probe-future-state__");
+  if (snapshot === null || standard === null || futureState === null) return null;
+  return snapshot === true && futureState === true && standard === false;
+}
+function memoryPosture() {
+  const ignored = isIgnored(".verity/memory/domain/__probe__.md");
+  if (ignored === null) return "unknown";
+  return ignored ? "ignored" : "committable";
+}
+function committedMemoryFiles() {
+  try {
+    return (0, import_node_child_process6.execSync)("git ls-files -z -- .verity/memory", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).split("\0").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+var OPT_OUT_COMMENT_LINES = /* @__PURE__ */ new Set([
+  MEMORY_OPT_OUT_MARKER,
+  '# Remove these three lines (or run "verity memory untrack") to stop tracking it.'
+]);
+function fenceMemoryLines(lines) {
+  const out = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === SUPERSEDED_COMMENT) {
+      out.push(...MEMORY_COMMENT);
+      continue;
+    }
+    if (SUPERSEDED_MEMORY_LINES.has(trimmed) || OPT_OUT_COMMENT_LINES.has(trimmed)) continue;
+    out.push(line);
+  }
+  return out;
+}
+function ensureVerityGitignore() {
+  let content = "";
+  try {
+    content = (0, import_node_fs11.readFileSync)(".gitignore", "utf-8");
+  } catch {
+  }
+  const hasMarker = content.includes(VERITY_GITIGNORE_MARKER);
+  const optedOut = content.includes(MEMORY_OPT_OUT_MARKER);
+  const lines = content.split("\n");
+  const needsRepair = lines.some((l) => BREAKING_ENTRIES.has(l.trim()));
+  const hasSupersededMemory = hasMarker && !optedOut && lines.some((l) => SUPERSEDED_MEMORY_LINES.has(l.trim()));
+  const memoryIsCommitted = hasSupersededMemory && committedMemoryFiles().length > 0;
+  const verified = (result) => semanticsHold() === false ? "conflict" : result;
+  if (hasMarker && !needsRepair && !hasSupersededMemory) return verified("covered");
+  if (!hasMarker && !needsRepair) {
+    if (semanticsHold() === true) return "covered";
+  }
+  try {
+    let next = lines;
+    if (needsRepair) {
+      next = next.map((l) => BREAKING_ENTRIES.has(l.trim()) ? ".verity/*" : l);
+    }
+    if (hasSupersededMemory && !memoryIsCommitted) {
+      next = fenceMemoryLines(next);
+    }
+    let text = next.join("\n");
+    if (!hasMarker) {
+      const sep3 = text === "" ? "" : text.endsWith("\n") ? "\n" : "\n\n";
+      text = text + sep3 + VERITY_GITIGNORE_BLOCK;
+    }
+    if (text !== content) (0, import_node_fs11.writeFileSync)(".gitignore", text);
+    return verified(
+      memoryIsCommitted ? "memory-tracked" : hasSupersededMemory ? "memory-fenced" : needsRepair ? "repaired" : "added"
+    );
+  } catch {
+    return "failed";
+  }
+}
+function untrackMemory() {
+  if (committedMemoryFiles().length === 0) return "none";
+  try {
+    (0, import_node_child_process6.execSync)("git rm -r --cached --quiet -- .verity/memory", { stdio: "pipe" });
+    return "untracked";
+  } catch {
+    return "failed";
+  }
+}
+function writeFencedBlock() {
+  let content = "";
+  try {
+    content = (0, import_node_fs11.readFileSync)(".gitignore", "utf-8");
+  } catch {
+  }
+  const hasMarker = content.includes(VERITY_GITIGNORE_MARKER);
+  let lines = content.split("\n").map((l) => BREAKING_ENTRIES.has(l.trim()) ? ".verity/*" : l);
+  lines = fenceMemoryLines(lines);
+  let text = lines.join("\n");
+  if (!hasMarker) {
+    const sep3 = text === "" ? "" : text.endsWith("\n") ? "\n" : "\n\n";
+    text = text + sep3 + VERITY_GITIGNORE_BLOCK;
+  }
+  try {
+    (0, import_node_fs11.writeFileSync)(".gitignore", text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function fenceMemory() {
+  let original = null;
+  try {
+    original = (0, import_node_fs11.readFileSync)(".gitignore", "utf-8");
+  } catch {
+    original = null;
+  }
+  const restore = () => {
+    try {
+      if (original === null) (0, import_node_fs11.rmSync)(".gitignore", { force: true });
+      else (0, import_node_fs11.writeFileSync)(".gitignore", original);
+    } catch {
+    }
+  };
+  if (!writeFencedBlock()) return { untracked: 0, ok: false };
+  if (memoryPosture() !== "ignored") {
+    restore();
+    return { untracked: 0, ok: false };
+  }
+  const tracked = committedMemoryFiles().length;
+  if (tracked > 0 && untrackMemory() === "failed") {
+    restore();
+    return { untracked: 0, ok: false };
+  }
+  return { untracked: tracked, ok: true };
+}
+function memoryOptOut() {
+  try {
+    return (0, import_node_fs11.readFileSync)(".gitignore", "utf-8").includes(MEMORY_OPT_OUT_MARKER);
+  } catch {
+    return false;
+  }
+}
+function keepMemoryTracked() {
+  let content = "";
+  try {
+    content = (0, import_node_fs11.readFileSync)(".gitignore", "utf-8");
+  } catch {
+  }
+  if (content.includes(MEMORY_OPT_OUT_MARKER)) return "already";
+  try {
+    const sep3 = content === "" ? "" : content.endsWith("\n") ? "\n" : "\n\n";
+    (0, import_node_fs11.writeFileSync)(".gitignore", content + sep3 + MEMORY_OPT_OUT_STANZA);
+  } catch {
+    return "failed";
+  }
+  return memoryPosture() === "ignored" ? "refused" : "recorded";
+}
+function committedVerityState() {
+  let out = "";
+  try {
+    out = (0, import_node_child_process6.execSync)("git ls-files -z -- .verity", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+  } catch {
+    return [];
+  }
+  return out.split("\0").filter(Boolean).filter((p) => p !== ".verity/standard.yaml" && !p.startsWith(".verity/memory/"));
+}
+function untrackVerityState() {
+  const tracked = committedVerityState();
+  if (tracked.length === 0) return "none";
+  try {
+    (0, import_node_child_process6.execSync)("git rm -r --cached --quiet -- .verity", { stdio: "pipe" });
+    const keeps = [".verity/standard.yaml"];
+    if (memoryPosture() === "committable") keeps.push(".verity/memory");
+    for (const keep of keeps) {
+      try {
+        (0, import_node_child_process6.execSync)(`git add -- "${keep}"`, { stdio: "pipe" });
+      } catch {
+      }
+    }
+    return "untracked";
+  } catch {
+    return "failed";
+  }
+}
+
+// src/lib/safe-path.ts
+var import_node_fs12 = require("node:fs");
 var import_node_path11 = require("node:path");
 function resolveInside(baseDir, candidate) {
   if (typeof candidate !== "string" || candidate.length === 0) return null;
@@ -14027,16 +14254,16 @@ function resolveInside(baseDir, candidate) {
   const baseSep = baseAbs.endsWith(import_node_path11.sep) ? baseAbs : baseAbs + import_node_path11.sep;
   if (full !== baseAbs && !full.startsWith(baseSep)) return null;
   try {
-    if ((0, import_node_fs11.existsSync)(baseAbs)) {
-      const realBase = (0, import_node_fs11.realpathSync)(baseAbs);
+    if ((0, import_node_fs12.existsSync)(baseAbs)) {
+      const realBase = (0, import_node_fs12.realpathSync)(baseAbs);
       const realBaseSep = realBase.endsWith(import_node_path11.sep) ? realBase : realBase + import_node_path11.sep;
       let probe = full;
-      while (!(0, import_node_fs11.existsSync)(probe)) {
+      while (!(0, import_node_fs12.existsSync)(probe)) {
         const parent = (0, import_node_path11.dirname)(probe);
         if (parent === probe) break;
         probe = parent;
       }
-      const realProbe = (0, import_node_fs11.realpathSync)(probe);
+      const realProbe = (0, import_node_fs12.realpathSync)(probe);
       if (realProbe !== realBase && !realProbe.startsWith(realBaseSep)) return null;
     }
   } catch {
@@ -14115,24 +14342,24 @@ async function ensureMemoryDir() {
   for (const domain of DOMAINS2) {
     await (0, import_promises8.mkdir)((0, import_node_path12.join)(memoryDir2(), domain), { recursive: true });
   }
-  if (!(0, import_node_fs12.existsSync)((0, import_node_path12.join)(memoryDir2(), "SCHEMA.md"))) {
+  if (!(0, import_node_fs13.existsSync)((0, import_node_path12.join)(memoryDir2(), "SCHEMA.md"))) {
     await (0, import_promises8.writeFile)((0, import_node_path12.join)(memoryDir2(), "SCHEMA.md"), SCHEMA_TEMPLATE);
   }
-  if (!(0, import_node_fs12.existsSync)((0, import_node_path12.join)(memoryDir2(), "index.md"))) {
+  if (!(0, import_node_fs13.existsSync)((0, import_node_path12.join)(memoryDir2(), "index.md"))) {
     await (0, import_promises8.writeFile)((0, import_node_path12.join)(memoryDir2(), "index.md"), "# Project Memory Index\n\nNo nodes yet. Run an analysis to start building the knowledge graph.\n");
   }
-  if (!(0, import_node_fs12.existsSync)((0, import_node_path12.join)(memoryDir2(), "log.md"))) {
+  if (!(0, import_node_fs13.existsSync)((0, import_node_path12.join)(memoryDir2(), "log.md"))) {
     await (0, import_promises8.writeFile)((0, import_node_path12.join)(memoryDir2(), "log.md"), "# Memory Log\n\n");
   }
 }
 async function buildManifest() {
-  if (!(0, import_node_fs12.existsSync)(memoryDir2())) {
+  if (!(0, import_node_fs13.existsSync)(memoryDir2())) {
     return { schema_version: 1, nodes: [], index_hash: null, log_length: 0 };
   }
   const nodes = [];
   for (const domain of DOMAINS2) {
     const domainDir = (0, import_node_path12.join)(memoryDir2(), domain);
-    if (!(0, import_node_fs12.existsSync)(domainDir)) continue;
+    if (!(0, import_node_fs13.existsSync)(domainDir)) continue;
     try {
       const files = await (0, import_promises8.readdir)(domainDir);
       for (const file of files) {
@@ -14168,10 +14395,10 @@ function hashContent(content) {
 }
 async function readOnDiskNodes() {
   const out = /* @__PURE__ */ new Map();
-  if (!(0, import_node_fs12.existsSync)(memoryDir2())) return out;
+  if (!(0, import_node_fs13.existsSync)(memoryDir2())) return out;
   for (const domain of DOMAINS2) {
     const domainDir = (0, import_node_path12.join)(memoryDir2(), domain);
-    if (!(0, import_node_fs12.existsSync)(domainDir)) continue;
+    if (!(0, import_node_fs13.existsSync)(domainDir)) continue;
     try {
       for (const file of await (0, import_promises8.readdir)(domainDir)) {
         if (!file.endsWith(".md")) continue;
@@ -14223,7 +14450,7 @@ async function computeEditedNodeUploads() {
   for (const [path, prevHash] of prev) {
     if (prevHash == null) continue;
     const full = (0, import_node_path12.join)(memoryDir2(), path);
-    if (!(0, import_node_fs12.existsSync)(full)) continue;
+    if (!(0, import_node_fs13.existsSync)(full)) continue;
     let content;
     try {
       content = await (0, import_promises8.readFile)(full, "utf-8");
@@ -14238,6 +14465,7 @@ async function computeDeletedNodePaths() {
   const prev = await readSyncBaseline();
   if (prev.size === 0) return [];
   const current = await readOnDiskNodes();
+  if (current.size === 0 && memoryPosture() === "ignored") return [];
   return [...prev.keys()].filter((p) => !current.has(p));
 }
 async function applyMemoryWrites(writes, opts = {}) {
@@ -14259,7 +14487,7 @@ async function applyMemoryWrites(writes, opts = {}) {
   const logLines = [`- ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16)} \u2014 Applied ${count} write(s) from server`];
   for (const n of notes) logLines.push(`  - ${n}`);
   try {
-    const existing = (0, import_node_fs12.existsSync)((0, import_node_path12.join)(memoryDir2(), "log.md")) ? await (0, import_promises8.readFile)((0, import_node_path12.join)(memoryDir2(), "log.md"), "utf-8") : "# Memory Log\n\n";
+    const existing = (0, import_node_fs13.existsSync)((0, import_node_path12.join)(memoryDir2(), "log.md")) ? await (0, import_promises8.readFile)((0, import_node_path12.join)(memoryDir2(), "log.md"), "utf-8") : "# Memory Log\n\n";
     await (0, import_promises8.writeFile)((0, import_node_path12.join)(memoryDir2(), "log.md"), existing + logLines.join("\n") + "\n");
   } catch {
   }
@@ -14280,7 +14508,7 @@ async function applyOneWrite(write, treePaths) {
       notes.push(`${write.path}: dropped unmatched file_globs [${grounded.dropped.join(", ")}]`);
     }
   }
-  if ((0, import_node_fs12.existsSync)(fullPath)) {
+  if ((0, import_node_fs13.existsSync)(fullPath)) {
     let existing = "";
     try {
       existing = await (0, import_promises8.readFile)(fullPath, "utf-8");
@@ -14334,7 +14562,7 @@ async function regenerateIndex() {
   let totalNodes = 0;
   for (const domain of DOMAINS2.filter((d) => d !== "_archive")) {
     const domainDir = (0, import_node_path12.join)(memoryDir2(), domain);
-    if (!(0, import_node_fs12.existsSync)(domainDir)) continue;
+    if (!(0, import_node_fs13.existsSync)(domainDir)) continue;
     try {
       const files = await (0, import_promises8.readdir)(domainDir);
       const mdFiles = files.filter((f) => f.endsWith(".md"));
@@ -14604,7 +14832,7 @@ function hasLegacyMemoryBlock(text) {
 async function ensureClaudeMdPointer(cwd = repoRoot()) {
   const claudeMdPath = (0, import_node_path12.join)(cwd, "CLAUDE.md");
   let existing = "";
-  if ((0, import_node_fs12.existsSync)(claudeMdPath)) {
+  if ((0, import_node_fs13.existsSync)(claudeMdPath)) {
     existing = await (0, import_promises8.readFile)(claudeMdPath, "utf-8");
   }
   let startTag = CLAUDE_MD_START;
@@ -14706,6 +14934,9 @@ file_globs: ["src/auth/**"]
 confidence: 0.5-1.0
 status: active | archived | superseded | orphan_flagged
 source: extractor | user | imported
+session: "<session key that produced this node>"   # absent = unattributed
+task: "<task id it was extracted from>"
+run: "<run id that produced it>"
 # ... (see full schema in MEMORY-GRAPH-PRD \xA76.3)
 ---
 
@@ -14740,7 +14971,7 @@ Body content (\u22648KB). Use [[node-id]] wikilinks for cross-references.
 `;
 
 // src/lib/dossier-session.ts
-var import_node_fs17 = require("node:fs");
+var import_node_fs18 = require("node:fs");
 var import_node_crypto7 = require("node:crypto");
 var import_node_path15 = require("node:path");
 
@@ -14847,7 +15078,7 @@ function statementAnchorKey(file, patternId) {
 
 // src/lib/dossier/log.ts
 var import_node_crypto4 = require("node:crypto");
-var import_node_fs13 = require("node:fs");
+var import_node_fs14 = require("node:fs");
 var import_node_path13 = require("node:path");
 var CRC_TABLE = (() => {
   const t = new Int32Array(256);
@@ -14867,7 +15098,7 @@ function crc32(s) {
 function openDossier(identity) {
   try {
     const dir = dossierDir(identity);
-    (0, import_node_fs13.mkdirSync)(dir, { recursive: true, mode: 448 });
+    (0, import_node_fs14.mkdirSync)(dir, { recursive: true, mode: 448 });
     return {
       dir,
       identity,
@@ -14935,7 +15166,7 @@ function appendEvent(d, ev) {
       at: ev.at ?? (/* @__PURE__ */ new Date()).toISOString(),
       ...ev
     });
-    (0, import_node_fs13.appendFileSync)(d.eventsPath, line, { mode: 384 });
+    (0, import_node_fs14.appendFileSync)(d.eventsPath, line, { mode: 384 });
     return true;
   } catch {
     return false;
@@ -14943,14 +15174,14 @@ function appendEvent(d, ev) {
 }
 function rotateIfNeeded2(d) {
   try {
-    if (!(0, import_node_fs13.existsSync)(d.eventsPath)) return;
-    if ((0, import_node_fs13.statSync)(d.eventsPath).size < ROTATE_BYTES) return;
-    (0, import_node_fs13.mkdirSync)(d.rotatedDir, { recursive: true, mode: 448 });
-    (0, import_node_fs13.renameSync)(d.eventsPath, (0, import_node_path13.join)(d.rotatedDir, `events.${Date.now()}.jsonl`));
-    const kept = (0, import_node_fs13.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).sort();
+    if (!(0, import_node_fs14.existsSync)(d.eventsPath)) return;
+    if ((0, import_node_fs14.statSync)(d.eventsPath).size < ROTATE_BYTES) return;
+    (0, import_node_fs14.mkdirSync)(d.rotatedDir, { recursive: true, mode: 448 });
+    (0, import_node_fs14.renameSync)(d.eventsPath, (0, import_node_path13.join)(d.rotatedDir, `events.${Date.now()}.jsonl`));
+    const kept = (0, import_node_fs14.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).sort();
     for (const stale of kept.slice(0, Math.max(0, kept.length - ROTATE_KEEP))) {
       try {
-        (0, import_node_fs13.renameSync)((0, import_node_path13.join)(d.rotatedDir, stale), (0, import_node_path13.join)(d.rotatedDir, `${stale}.pruned`));
+        (0, import_node_fs14.renameSync)((0, import_node_path13.join)(d.rotatedDir, stale), (0, import_node_path13.join)(d.rotatedDir, `${stale}.pruned`));
       } catch {
       }
     }
@@ -14960,7 +15191,7 @@ function rotateIfNeeded2(d) {
 
 // src/lib/dossier/fold-dossier.ts
 var import_node_crypto5 = require("node:crypto");
-var import_node_fs14 = require("node:fs");
+var import_node_fs15 = require("node:fs");
 var import_node_path14 = require("node:path");
 var EMPTY_CAPABILITIES = () => ({
   human_reachable: { value: "unknown", tier: "unknown" },
@@ -15012,12 +15243,12 @@ function foldDossier(d, opts = {}) {
     }
   };
   try {
-    if ((0, import_node_fs14.existsSync)(d.rotatedDir)) {
-      const files = (0, import_node_fs14.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).sort();
+    if ((0, import_node_fs15.existsSync)(d.rotatedDir)) {
+      const files = (0, import_node_fs15.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).sort();
       state.meta.rotations = files.length;
       for (const f of files) {
         try {
-          ingest((0, import_node_fs14.readFileSync)((0, import_node_path14.join)(d.rotatedDir, f), "utf8"));
+          ingest((0, import_node_fs15.readFileSync)((0, import_node_path14.join)(d.rotatedDir, f), "utf8"));
         } catch {
           state.meta.dropped_lines++;
         }
@@ -15026,9 +15257,9 @@ function foldDossier(d, opts = {}) {
   } catch {
   }
   try {
-    if ((0, import_node_fs14.existsSync)(d.eventsPath)) {
-      state.meta.upto_offset = (0, import_node_fs14.statSync)(d.eventsPath).size;
-      ingest((0, import_node_fs14.readFileSync)(d.eventsPath, "utf8"));
+    if ((0, import_node_fs15.existsSync)(d.eventsPath)) {
+      state.meta.upto_offset = (0, import_node_fs15.statSync)(d.eventsPath).size;
+      ingest((0, import_node_fs15.readFileSync)(d.eventsPath, "utf8"));
     }
   } catch {
   }
@@ -15299,7 +15530,7 @@ function applyBounds(state, input) {
 }
 
 // src/lib/dossier/cache.ts
-var import_node_fs15 = require("node:fs");
+var import_node_fs16 = require("node:fs");
 function compactState(s) {
   const ms = (iso) => Date.parse(iso) || 0;
   return {
@@ -15428,20 +15659,20 @@ function encodeState(s) {
 function writeFoldCache(d, state) {
   try {
     const tmp = `${d.foldPath}.${process.pid}.tmp`;
-    (0, import_node_fs15.writeFileSync)(tmp, encodeState(state), { mode: 384 });
-    (0, import_node_fs15.renameSync)(tmp, d.foldPath);
+    (0, import_node_fs16.writeFileSync)(tmp, encodeState(state), { mode: 384 });
+    (0, import_node_fs16.renameSync)(tmp, d.foldPath);
   } catch {
   }
 }
 function readFoldCache(d) {
   try {
-    if (!(0, import_node_fs15.existsSync)(d.foldPath)) return null;
-    const raw = JSON.parse((0, import_node_fs15.readFileSync)(d.foldPath, "utf8"));
+    if (!(0, import_node_fs16.existsSync)(d.foldPath)) return null;
+    const raw = JSON.parse((0, import_node_fs16.readFileSync)(d.foldPath, "utf8"));
     if (raw?.v !== 1) return null;
     const cached2 = expandState(raw);
     if (!cached2?.meta) return null;
-    const size = (0, import_node_fs15.existsSync)(d.eventsPath) ? (0, import_node_fs15.statSync)(d.eventsPath).size : 0;
-    const rotations = (0, import_node_fs15.existsSync)(d.rotatedDir) ? (0, import_node_fs15.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).length : 0;
+    const size = (0, import_node_fs16.existsSync)(d.eventsPath) ? (0, import_node_fs16.statSync)(d.eventsPath).size : 0;
+    const rotations = (0, import_node_fs16.existsSync)(d.rotatedDir) ? (0, import_node_fs16.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).length : 0;
     if (cached2.meta.upto_offset !== size || cached2.meta.rotations !== rotations) return null;
     return cached2;
   } catch {
@@ -15492,13 +15723,13 @@ function assessContinuity(i) {
 
 // src/lib/dossier/reanchor.ts
 var import_node_crypto6 = require("node:crypto");
-var import_node_fs16 = require("node:fs");
+var import_node_fs17 = require("node:fs");
 function lineSha(text) {
   return (0, import_node_crypto6.createHash)("sha256").update(text.trim()).digest("hex").slice(0, HASH_WIDTH);
 }
 function fileHash(path) {
   try {
-    return (0, import_node_crypto6.createHash)("sha256").update((0, import_node_fs16.readFileSync)(path)).digest("hex").slice(0, HASH_WIDTH);
+    return (0, import_node_crypto6.createHash)("sha256").update((0, import_node_fs17.readFileSync)(path)).digest("hex").slice(0, HASH_WIDTH);
   } catch {
     return null;
   }
@@ -15870,14 +16101,14 @@ function foreignAuthoredPaths(identity, opts = {}) {
   let sessions = 0;
   try {
     const dir = treeDir(identity);
-    if (!(0, import_node_fs17.existsSync)(dir)) return { paths: [], sessions: 0 };
-    for (const entry of (0, import_node_fs17.readdirSync)(dir, { withFileTypes: true })) {
+    if (!(0, import_node_fs18.existsSync)(dir)) return { paths: [], sessions: 0 };
+    for (const entry of (0, import_node_fs18.readdirSync)(dir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       if (entry.name === identity.sessionKey) continue;
       const log = (0, import_node_path15.join)(dir, entry.name, "events.jsonl");
       try {
-        if (!(0, import_node_fs17.existsSync)(log)) continue;
-        if (now - (0, import_node_fs17.statSync)(log).mtimeMs > windowMs) continue;
+        if (!(0, import_node_fs18.existsSync)(log)) continue;
+        if (now - (0, import_node_fs18.statSync)(log).mtimeMs > windowMs) continue;
         const sib = {
           dir: (0, import_node_path15.join)(dir, entry.name),
           identity,
@@ -15912,13 +16143,13 @@ function pruneOldDossiers(identity, maxAgeMs = 7 * 24 * 60 * 60 * 1e3) {
   try {
     const mine = dossierDir(identity);
     const userDir = (0, import_node_path15.dirname)((0, import_node_path15.dirname)(mine));
-    if (!(0, import_node_fs17.existsSync)(userDir)) return 0;
+    if (!(0, import_node_fs18.existsSync)(userDir)) return 0;
     const cutoff = Date.now() - maxAgeMs;
-    for (const tree of (0, import_node_fs17.readdirSync)(userDir, { withFileTypes: true })) {
+    for (const tree of (0, import_node_fs18.readdirSync)(userDir, { withFileTypes: true })) {
       if (!tree.isDirectory()) continue;
       const treePath = (0, import_node_path15.join)(userDir, tree.name);
       let live = 0;
-      for (const entry of (0, import_node_fs17.readdirSync)(treePath, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs18.readdirSync)(treePath, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         const dir = (0, import_node_path15.join)(treePath, entry.name);
         if (dir === mine) {
@@ -15927,9 +16158,9 @@ function pruneOldDossiers(identity, maxAgeMs = 7 * 24 * 60 * 60 * 1e3) {
         }
         try {
           const log = (0, import_node_path15.join)(dir, "events.jsonl");
-          const at = (0, import_node_fs17.existsSync)(log) ? (0, import_node_fs17.statSync)(log).mtimeMs : (0, import_node_fs17.statSync)(dir).mtimeMs;
+          const at = (0, import_node_fs18.existsSync)(log) ? (0, import_node_fs18.statSync)(log).mtimeMs : (0, import_node_fs18.statSync)(dir).mtimeMs;
           if (at < cutoff) {
-            (0, import_node_fs17.rmSync)(dir, { recursive: true, force: true });
+            (0, import_node_fs18.rmSync)(dir, { recursive: true, force: true });
             removed++;
           } else {
             live++;
@@ -15939,7 +16170,7 @@ function pruneOldDossiers(identity, maxAgeMs = 7 * 24 * 60 * 60 * 1e3) {
       }
       if (live === 0) {
         try {
-          (0, import_node_fs17.rmSync)(treePath, { recursive: false, force: false });
+          (0, import_node_fs18.rmSync)(treePath, { recursive: false, force: false });
         } catch {
         }
       }
@@ -15956,8 +16187,8 @@ function sessionDossier(token, sessionId) {
 }
 function hasActiveGoal(d) {
   try {
-    if (!(0, import_node_fs17.existsSync)(d.eventsPath)) return false;
-    return (0, import_node_fs17.readFileSync)(d.eventsPath, "utf8").includes('"k":"goal"');
+    if (!(0, import_node_fs18.existsSync)(d.eventsPath)) return false;
+    return (0, import_node_fs18.readFileSync)(d.eventsPath, "utf8").includes('"k":"goal"');
   } catch {
     return false;
   }
@@ -16050,7 +16281,7 @@ function recordVerdict(d, v) {
     if (!lines.has(f.file)) {
       try {
         const abs = (0, import_node_path15.join)(root, f.file);
-        lines.set(f.file, (0, import_node_fs17.existsSync)(abs) ? (0, import_node_fs17.readFileSync)(abs, "utf8").split("\n") : null);
+        lines.set(f.file, (0, import_node_fs18.existsSync)(abs) ? (0, import_node_fs18.readFileSync)(abs, "utf8").split("\n") : null);
       } catch {
         lines.set(f.file, null);
       }
@@ -16151,7 +16382,7 @@ function recallMemory(d, identity, opts) {
       readFileLines: (file) => {
         try {
           const abs = (0, import_node_path15.join)(root, file);
-          return (0, import_node_fs17.existsSync)(abs) ? (0, import_node_fs17.readFileSync)(abs, "utf8").split("\n") : null;
+          return (0, import_node_fs18.existsSync)(abs) ? (0, import_node_fs18.readFileSync)(abs, "utf8").split("\n") : null;
         } catch {
           return null;
         }
@@ -16295,21 +16526,21 @@ async function fireClassify(prompt, sessionId, globals) {
 }
 
 // src/commands/lifecycle.ts
-var import_node_fs21 = require("node:fs");
+var import_node_fs22 = require("node:fs");
 var import_node_path19 = require("node:path");
 
 // src/lib/baseline.ts
-var import_node_fs20 = require("node:fs");
+var import_node_fs21 = require("node:fs");
 var import_node_path18 = require("node:path");
 var import_node_crypto9 = require("node:crypto");
 
 // src/lib/snapshot.ts
-var import_node_fs19 = require("node:fs");
+var import_node_fs20 = require("node:fs");
 var import_node_path17 = require("node:path");
-var import_node_child_process6 = require("node:child_process");
+var import_node_child_process7 = require("node:child_process");
 
 // src/lib/files.ts
-var import_node_fs18 = require("node:fs");
+var import_node_fs19 = require("node:fs");
 var import_node_path16 = require("node:path");
 var LANG_MAP = {
   // Analyzable (static analysis + Gemini)
@@ -16386,7 +16617,7 @@ function sortByMtime(files) {
     const resolved = resolveFile(f);
     if (!resolved) return null;
     try {
-      const stat3 = (0, import_node_fs18.statSync)(resolved);
+      const stat3 = (0, import_node_fs19.statSync)(resolved);
       return { path: f, resolved, mtime: stat3.mtimeMs };
     } catch {
       return null;
@@ -16419,7 +16650,7 @@ function collectCodeDelta(files, opts) {
     }
     let size;
     try {
-      size = (0, import_node_fs18.statSync)(resolved).size;
+      size = (0, import_node_fs19.statSync)(resolved).size;
     } catch {
       exclude(filepath, "not-stattable");
       continue;
@@ -16436,7 +16667,7 @@ function collectCodeDelta(files, opts) {
     }
     let content;
     try {
-      content = (0, import_node_fs18.readFileSync)(resolved, "utf-8");
+      content = (0, import_node_fs19.readFileSync)(resolved, "utf-8");
     } catch {
       exclude(filepath, "not-readable");
       continue;
@@ -16475,7 +16706,7 @@ function collectCodeDelta(files, opts) {
 
 // src/lib/snapshot.ts
 function generateSnapshotDiffs(files) {
-  if (!(0, import_node_fs19.existsSync)(SNAPSHOT_DIR)) {
+  if (!(0, import_node_fs20.existsSync)(SNAPSHOT_DIR)) {
     return { diffs: [], has_snapshots: false };
   }
   const diffs = [];
@@ -16483,8 +16714,8 @@ function generateSnapshotDiffs(files) {
     if (!resolveInside(SNAPSHOT_DIR, file.path)) continue;
     const snapshotPath = (0, import_node_path17.join)(SNAPSHOT_DIR, file.path);
     const language = file.language ?? detectLanguage(file.path);
-    if ((0, import_node_fs19.existsSync)(snapshotPath)) {
-      const oldContent = (0, import_node_fs19.readFileSync)(snapshotPath, "utf-8");
+    if ((0, import_node_fs20.existsSync)(snapshotPath)) {
+      const oldContent = (0, import_node_fs20.readFileSync)(snapshotPath, "utf-8");
       if (oldContent === file.content) continue;
       const diff = computeDiff(oldContent, file.content, file.path);
       if (diff) {
@@ -16511,8 +16742,8 @@ function saveSnapshots(files) {
     if (!resolveInside(SNAPSHOT_DIR, file.path)) continue;
     const snapshotPath = (0, import_node_path17.join)(SNAPSHOT_DIR, file.path);
     snapshotPaths.add(snapshotPath);
-    (0, import_node_fs19.mkdirSync)((0, import_node_path17.dirname)(snapshotPath), { recursive: true });
-    (0, import_node_fs19.writeFileSync)(snapshotPath, file.content);
+    (0, import_node_fs20.mkdirSync)((0, import_node_path17.dirname)(snapshotPath), { recursive: true });
+    (0, import_node_fs20.writeFileSync)(snapshotPath, file.content);
   }
   cleanStaleSnapshots(SNAPSHOT_DIR, snapshotPaths);
 }
@@ -16520,10 +16751,10 @@ function computeDiff(oldContent, newContent, filePath) {
   const tmpOld = (0, import_node_path17.join)(SNAPSHOT_DIR, ".diff-old.tmp");
   const tmpNew = (0, import_node_path17.join)(SNAPSHOT_DIR, ".diff-new.tmp");
   try {
-    (0, import_node_fs19.mkdirSync)(SNAPSHOT_DIR, { recursive: true });
-    (0, import_node_fs19.writeFileSync)(tmpOld, oldContent);
-    (0, import_node_fs19.writeFileSync)(tmpNew, newContent);
-    const result = (0, import_node_child_process6.execSync)(
+    (0, import_node_fs20.mkdirSync)(SNAPSHOT_DIR, { recursive: true });
+    (0, import_node_fs20.writeFileSync)(tmpOld, oldContent);
+    (0, import_node_fs20.writeFileSync)(tmpNew, newContent);
+    const result = (0, import_node_child_process7.execSync)(
       `git diff --no-index --unified=10 -- "${tmpOld}" "${tmpNew}"`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     );
@@ -16536,32 +16767,32 @@ function computeDiff(oldContent, newContent, filePath) {
     return null;
   } finally {
     try {
-      (0, import_node_fs19.unlinkSync)(tmpOld);
+      (0, import_node_fs20.unlinkSync)(tmpOld);
     } catch {
     }
     try {
-      (0, import_node_fs19.unlinkSync)(tmpNew);
+      (0, import_node_fs20.unlinkSync)(tmpNew);
     } catch {
     }
   }
 }
 function cleanStaleSnapshots(dir, keepSet) {
-  if (!(0, import_node_fs19.existsSync)(dir)) return;
+  if (!(0, import_node_fs20.existsSync)(dir)) return;
   try {
-    const entries = (0, import_node_fs19.readdirSync)(dir, { withFileTypes: true });
+    const entries = (0, import_node_fs20.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (dir === SNAPSHOT_DIR && (entry.name === ".diff-old.tmp" || entry.name === ".diff-new.tmp")) continue;
       const fullPath = (0, import_node_path17.join)(dir, entry.name);
       if (entry.isDirectory()) {
         cleanStaleSnapshots(fullPath, keepSet);
         try {
-          const remaining = (0, import_node_fs19.readdirSync)(fullPath);
-          if (remaining.length === 0) (0, import_node_fs19.rmdirSync)(fullPath);
+          const remaining = (0, import_node_fs20.readdirSync)(fullPath);
+          if (remaining.length === 0) (0, import_node_fs20.rmdirSync)(fullPath);
         } catch {
         }
       } else if (!keepSet.has(fullPath)) {
         try {
-          (0, import_node_fs19.unlinkSync)(fullPath);
+          (0, import_node_fs20.unlinkSync)(fullPath);
         } catch {
         }
       }
@@ -16592,8 +16823,8 @@ var CARRY_FILE = `${BASELINE_DIR}/.carry`;
 var CARRY_WINDOW_MS = 12e4;
 function writeCarry(sessionId, headSha) {
   try {
-    (0, import_node_fs20.mkdirSync)(projectPath(BASELINE_DIR), { recursive: true });
-    (0, import_node_fs20.writeFileSync)(
+    (0, import_node_fs21.mkdirSync)(projectPath(BASELINE_DIR), { recursive: true });
+    (0, import_node_fs21.writeFileSync)(
       projectPath(CARRY_FILE),
       JSON.stringify({ from_key: sessionKey(sessionId), head_sha: headSha, ts: Date.now() })
     );
@@ -16603,10 +16834,10 @@ function writeCarry(sessionId, headSha) {
 function claimCarry(newKey) {
   const carryPath = projectPath(CARRY_FILE);
   try {
-    if (!(0, import_node_fs20.existsSync)(carryPath)) return null;
-    const carry = JSON.parse((0, import_node_fs20.readFileSync)(carryPath, "utf-8"));
+    if (!(0, import_node_fs21.existsSync)(carryPath)) return null;
+    const carry = JSON.parse((0, import_node_fs21.readFileSync)(carryPath, "utf-8"));
     try {
-      (0, import_node_fs20.rmSync)(carryPath, { force: true });
+      (0, import_node_fs21.rmSync)(carryPath, { force: true });
     } catch {
     }
     if (!carry?.from_key || typeof carry.ts !== "number") return null;
@@ -16617,11 +16848,11 @@ function claimCarry(newKey) {
     if (!prior) return null;
     const toDir = sessionDir(newKey);
     try {
-      (0, import_node_fs20.rmSync)(toDir, { recursive: true, force: true });
+      (0, import_node_fs21.rmSync)(toDir, { recursive: true, force: true });
     } catch {
     }
-    (0, import_node_fs20.renameSync)(fromDir, toDir);
-    (0, import_node_fs20.writeFileSync)(manifestPath(toDir), JSON.stringify({ ...prior, session_id: newKey }) + "\n");
+    (0, import_node_fs21.renameSync)(fromDir, toDir);
+    (0, import_node_fs21.writeFileSync)(manifestPath(toDir), JSON.stringify({ ...prior, session_id: newKey }) + "\n");
     return readManifest(toDir);
   } catch {
     return null;
@@ -16645,21 +16876,21 @@ function captureBaseline(opts = {}) {
   const head_sha = getCurrentCommit();
   const dirty = getDirtyFiles();
   try {
-    (0, import_node_fs20.rmSync)(dir, { recursive: true, force: true });
+    (0, import_node_fs21.rmSync)(dir, { recursive: true, force: true });
   } catch {
   }
   const filesDir = (0, import_node_path18.join)(dir, "files");
   const mirrored = [];
   try {
-    (0, import_node_fs20.mkdirSync)(filesDir, { recursive: true });
+    (0, import_node_fs21.mkdirSync)(filesDir, { recursive: true });
     for (const p of dirty) {
       if (p.includes("..")) continue;
       const content = safeReadForMirror(projectPath(p));
       if (content === null) continue;
       const dest = mirrorPath(dir, p);
       try {
-        (0, import_node_fs20.mkdirSync)((0, import_node_path18.dirname)(dest), { recursive: true });
-        (0, import_node_fs20.writeFileSync)(dest, content);
+        (0, import_node_fs21.mkdirSync)((0, import_node_path18.dirname)(dest), { recursive: true });
+        (0, import_node_fs21.writeFileSync)(dest, content);
         mirrored.push(p);
       } catch {
       }
@@ -16674,8 +16905,8 @@ function captureBaseline(opts = {}) {
     version: BASELINE_VERSION
   };
   try {
-    (0, import_node_fs20.mkdirSync)(dir, { recursive: true });
-    (0, import_node_fs20.writeFileSync)(manifestPath(dir), JSON.stringify(baseline));
+    (0, import_node_fs21.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs21.writeFileSync)(manifestPath(dir), JSON.stringify(baseline));
   } catch {
   }
   pruneOldBaselines();
@@ -16686,9 +16917,9 @@ function readBaseline(sessionId) {
 }
 function readManifest(dir) {
   const mp = manifestPath(dir);
-  if (!(0, import_node_fs20.existsSync)(mp)) return null;
+  if (!(0, import_node_fs21.existsSync)(mp)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs20.readFileSync)(mp, "utf-8"));
+    const parsed = JSON.parse((0, import_node_fs21.readFileSync)(mp, "utf-8"));
     if (typeof parsed.head_sha !== "string" || typeof parsed.captured_at !== "number" || !Array.isArray(parsed.dirty_paths) || parsed.version !== BASELINE_VERSION) {
       return null;
     }
@@ -16719,9 +16950,9 @@ function preImage(repoRelPath, baseline) {
 function resolvePreImage(repoRelPath, baseline) {
   if (baseline.dirty_paths.includes(repoRelPath)) {
     const mp = mirrorPath(sessionDir(sessionKey(baseline.session_id)), repoRelPath);
-    if ((0, import_node_fs20.existsSync)(mp)) {
+    if ((0, import_node_fs21.existsSync)(mp)) {
       try {
-        return { content: (0, import_node_fs20.readFileSync)(mp, "utf-8"), existed: true };
+        return { content: (0, import_node_fs21.readFileSync)(mp, "utf-8"), existed: true };
       } catch {
       }
     }
@@ -16766,8 +16997,8 @@ function absorbIntoBaseline(paths, sessionId) {
       const content = safeReadForMirror(projectPath(p));
       if (content === null) continue;
       const dest = mirrorPath(dir, p);
-      (0, import_node_fs20.mkdirSync)((0, import_node_path18.dirname)(dest), { recursive: true });
-      (0, import_node_fs20.writeFileSync)(dest, content);
+      (0, import_node_fs21.mkdirSync)((0, import_node_path18.dirname)(dest), { recursive: true });
+      (0, import_node_fs21.writeFileSync)(dest, content);
       dirty.add(p);
       adopted++;
     } catch {
@@ -16776,7 +17007,7 @@ function absorbIntoBaseline(paths, sessionId) {
   if (adopted === 0) return 0;
   try {
     const updated = { ...baseline, dirty_paths: [...dirty] };
-    (0, import_node_fs20.writeFileSync)(manifestPath(dir), JSON.stringify(updated));
+    (0, import_node_fs21.writeFileSync)(manifestPath(dir), JSON.stringify(updated));
     preImageCache.delete(baseline);
   } catch {
     return 0;
@@ -16787,7 +17018,7 @@ function changedSinceBaseline(repoRelPath, baseline) {
   const pre = preImage(repoRelPath, baseline);
   let current;
   try {
-    current = (0, import_node_fs20.readFileSync)(projectPath(repoRelPath), "utf-8");
+    current = (0, import_node_fs21.readFileSync)(projectPath(repoRelPath), "utf-8");
   } catch {
     return pre.existed;
   }
@@ -16796,8 +17027,8 @@ function changedSinceBaseline(repoRelPath, baseline) {
 }
 function safeReadForMirror(absPath) {
   try {
-    if ((0, import_node_fs20.statSync)(absPath).size > MIRROR_MAX_BYTES) return null;
-    const buf = (0, import_node_fs20.readFileSync)(absPath);
+    if ((0, import_node_fs21.statSync)(absPath).size > MIRROR_MAX_BYTES) return null;
+    const buf = (0, import_node_fs21.readFileSync)(absPath);
     if (buf.includes(0)) return null;
     return buf.toString("utf-8");
   } catch {
@@ -16808,7 +17039,7 @@ function pruneOldBaselines() {
   const root = projectPath(BASELINE_DIR);
   let entries;
   try {
-    entries = (0, import_node_fs20.readdirSync)(root);
+    entries = (0, import_node_fs21.readdirSync)(root);
   } catch {
     return;
   }
@@ -16818,8 +17049,8 @@ function pruneOldBaselines() {
     const manifest = readManifest(dir);
     if (!manifest) {
       try {
-        if (now - (0, import_node_fs20.statSync)(dir).mtimeMs > BASELINE_TTL_MS) {
-          (0, import_node_fs20.rmSync)(dir, { recursive: true, force: true });
+        if (now - (0, import_node_fs21.statSync)(dir).mtimeMs > BASELINE_TTL_MS) {
+          (0, import_node_fs21.rmSync)(dir, { recursive: true, force: true });
         }
       } catch {
       }
@@ -16827,7 +17058,7 @@ function pruneOldBaselines() {
     }
     if (now - manifest.captured_at <= BASELINE_TTL_MS) continue;
     try {
-      (0, import_node_fs20.rmSync)(dir, { recursive: true, force: true });
+      (0, import_node_fs21.rmSync)(dir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -17003,7 +17234,7 @@ function buildCompactionContext(session) {
     readFileLines: (file) => {
       try {
         const abs = (0, import_node_path19.join)(root, file);
-        return (0, import_node_fs21.existsSync)(abs) ? (0, import_node_fs21.readFileSync)(abs, "utf8").split("\n") : null;
+        return (0, import_node_fs22.existsSync)(abs) ? (0, import_node_fs22.readFileSync)(abs, "utf8").split("\n") : null;
       } catch {
         return null;
       }
@@ -17060,18 +17291,18 @@ async function readHookStdin() {
 
 // src/commands/standard.ts
 var import_promises12 = require("node:fs/promises");
-var import_node_fs28 = require("node:fs");
+var import_node_fs29 = require("node:fs");
 var import_yaml3 = __toESM(require_dist());
 
 // src/lib/synthesize.ts
-var import_node_child_process8 = require("node:child_process");
-var import_node_fs24 = require("node:fs");
+var import_node_child_process9 = require("node:child_process");
+var import_node_fs25 = require("node:fs");
 var import_promises9 = require("node:fs/promises");
 var import_node_path22 = require("node:path");
 var import_yaml = __toESM(require_dist());
 
 // src/lib/data-dir.ts
-var import_node_fs22 = require("node:fs");
+var import_node_fs23 = require("node:fs");
 var import_node_path20 = require("node:path");
 function resolveDataDir() {
   const candidates2 = [
@@ -17093,7 +17324,7 @@ function resolveDataDir() {
     ...process.env.VERITY_DEV_DATA_DIR ? [process.env.VERITY_DEV_DATA_DIR] : []
   ];
   for (const candidate of candidates2) {
-    if ((0, import_node_fs22.existsSync)((0, import_node_path20.join)(candidate, "skills"))) {
+    if ((0, import_node_fs23.existsSync)((0, import_node_path20.join)(candidate, "skills"))) {
       return candidate;
     }
   }
@@ -17106,8 +17337,8 @@ function setupDataPath(file) {
 }
 
 // src/lib/detect.ts
-var import_node_child_process7 = require("node:child_process");
-var import_node_fs23 = require("node:fs");
+var import_node_child_process8 = require("node:child_process");
+var import_node_fs24 = require("node:fs");
 var import_node_path21 = require("node:path");
 var TOOLED_LANGUAGES = /* @__PURE__ */ new Set([
   "typescript",
@@ -17139,19 +17370,19 @@ var IGNORED_SEGMENTS = [
   ".verity",
   ".codacy"
 ];
-function isIgnored(path) {
+function isIgnored2(path) {
   const parts = path.split("/");
   return parts.some((p) => IGNORED_SEGMENTS.includes(p));
 }
 function listProjectFiles(root) {
   try {
-    const out = (0, import_node_child_process7.execSync)("git ls-files -z", {
+    const out = (0, import_node_child_process8.execSync)("git ls-files -z", {
       cwd: root,
       encoding: "utf-8",
       maxBuffer: 32 * 1024 * 1024,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    const tracked = out.split("\0").filter(Boolean).filter((p) => !isIgnored(p));
+    const tracked = out.split("\0").filter(Boolean).filter((p) => !isIgnored2(p));
     if (tracked.length > 0) return tracked;
   } catch {
   }
@@ -17165,7 +17396,7 @@ function walk(root) {
     if (depth > WALK_MAX_DEPTH || found.length >= WALK_MAX_FILES) return;
     let entries;
     try {
-      entries = (0, import_node_fs23.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs24.readdirSync)(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -17240,7 +17471,7 @@ var TOOL_CONFIG_MARKERS = [
 ];
 function readJson(path) {
   try {
-    return JSON.parse((0, import_node_fs23.readFileSync)(path, "utf-8"));
+    return JSON.parse((0, import_node_fs24.readFileSync)(path, "utf-8"));
   } catch {
     return null;
   }
@@ -17273,9 +17504,9 @@ function declaredDependencies(root, files) {
     ...files.filter((f) => f.includes("/") && /(^|\/)(pyproject\.toml|requirements\.txt)$/.test(f)).slice(0, NESTED_MANIFEST_LIMIT).map((f) => (0, import_node_path21.join)(root, f))
   ];
   for (const path of pythonManifests) {
-    if (!(0, import_node_fs23.existsSync)(path)) continue;
+    if (!(0, import_node_fs24.existsSync)(path)) continue;
     try {
-      const text = (0, import_node_fs23.readFileSync)(path, "utf-8");
+      const text = (0, import_node_fs24.readFileSync)(path, "utf-8");
       for (const m of text.matchAll(/^\s*["']?([A-Za-z][A-Za-z0-9._-]+)/gm)) names2.push(m[1]);
       for (const line of text.split("\n")) {
         if (!/dependencies\s*=/.test(line)) continue;
@@ -17289,9 +17520,9 @@ function declaredDependencies(root, files) {
     ...files.filter((f) => f.includes("/") && (0, import_node_path21.basename)(f) === "go.mod").slice(0, NESTED_MANIFEST_LIMIT).map((f) => (0, import_node_path21.join)(root, f))
   ];
   for (const path of goMods) {
-    if (!(0, import_node_fs23.existsSync)(path)) continue;
+    if (!(0, import_node_fs24.existsSync)(path)) continue;
     try {
-      const text = (0, import_node_fs23.readFileSync)(path, "utf-8");
+      const text = (0, import_node_fs24.readFileSync)(path, "utf-8");
       for (const m of text.matchAll(/^\s+([\w.-]+\/[\w./-]+)\s+v/gm)) {
         names2.push(m[1].replace(/^github\.com\//, ""));
       }
@@ -17300,9 +17531,9 @@ function declaredDependencies(root, files) {
   }
   for (const file of ["pom.xml", "build.gradle", "build.gradle.kts", "Gemfile", "Cargo.toml"]) {
     const path = (0, import_node_path21.join)(root, file);
-    if (!(0, import_node_fs23.existsSync)(path)) continue;
+    if (!(0, import_node_fs24.existsSync)(path)) continue;
     try {
-      const text = (0, import_node_fs23.readFileSync)(path, "utf-8");
+      const text = (0, import_node_fs24.readFileSync)(path, "utf-8");
       for (const m of text.matchAll(/["'<]([A-Za-z][A-Za-z0-9._-]{2,})["'>]/g)) names2.push(m[1]);
     } catch {
     }
@@ -17310,7 +17541,7 @@ function declaredDependencies(root, files) {
   return names2;
 }
 function detectBuildSystem(root, files) {
-  const has = (f) => (0, import_node_fs23.existsSync)((0, import_node_path21.join)(root, f)) || files.some((p) => (0, import_node_path21.basename)(p) === f);
+  const has = (f) => (0, import_node_fs24.existsSync)((0, import_node_path21.join)(root, f)) || files.some((p) => (0, import_node_path21.basename)(p) === f);
   if (has("pnpm-lock.yaml")) return "pnpm";
   if (has("yarn.lock")) return "yarn";
   if (has("bun.lock") || has("bun.lockb")) return "bun";
@@ -17327,7 +17558,7 @@ function detectBuildSystem(root, files) {
 }
 function detectArchitecture(root, files) {
   const workspaceMarkers = ["lerna.json", "pnpm-workspace.yaml", "nx.json", "turbo.json", "rush.json"];
-  if (workspaceMarkers.some((m) => (0, import_node_fs23.existsSync)((0, import_node_path21.join)(root, m)))) return "monorepo";
+  if (workspaceMarkers.some((m) => (0, import_node_fs24.existsSync)((0, import_node_path21.join)(root, m)))) return "monorepo";
   const pkg = readJson((0, import_node_path21.join)(root, "package.json"));
   if (pkg && "workspaces" in pkg) return "monorepo";
   const manifests = files.filter((f) => /(^|\/)(package\.json|go\.mod|pyproject\.toml|Cargo\.toml|pom\.xml)$/.test(f));
@@ -17352,8 +17583,8 @@ function measureAvgFileLength(root, files, languages) {
   for (let i = 0; i < candidates2.length; i += stride) {
     const path = (0, import_node_path21.join)(root, candidates2[i]);
     try {
-      if ((0, import_node_fs23.statSync)(path).size > 2 * 1024 * 1024) continue;
-      total += (0, import_node_fs23.readFileSync)(path, "utf-8").split("\n").length;
+      if ((0, import_node_fs24.statSync)(path).size > 2 * 1024 * 1024) continue;
+      total += (0, import_node_fs24.readFileSync)(path, "utf-8").split("\n").length;
       counted++;
     } catch {
     }
@@ -17383,7 +17614,7 @@ function detectProject(root = repoRoot()) {
   const existingToolConfigs = [];
   for (const [tool, markers] of TOOL_CONFIG_MARKERS) {
     for (const marker of markers) {
-      if ((0, import_node_fs23.existsSync)((0, import_node_path21.join)(root, marker))) {
+      if ((0, import_node_fs24.existsSync)((0, import_node_path21.join)(root, marker))) {
         existingToolConfigs.push({ tool, path: `./${marker}` });
         break;
       }
@@ -17488,8 +17719,8 @@ ${closingNote(input.origin)}
 
 // src/lib/synthesize.ts
 function loadCatalog() {
-  const catalog = (0, import_yaml.parse)((0, import_node_fs24.readFileSync)(setupDataPath("patterns-reference.yaml"), "utf-8"));
-  const template = (0, import_yaml.parse)((0, import_node_fs24.readFileSync)(setupDataPath("standard-template.yaml"), "utf-8"));
+  const catalog = (0, import_yaml.parse)((0, import_node_fs25.readFileSync)(setupDataPath("patterns-reference.yaml"), "utf-8"));
+  const template = (0, import_yaml.parse)((0, import_node_fs25.readFileSync)(setupDataPath("standard-template.yaml"), "utf-8"));
   return { catalog, template };
 }
 function selectTools(languages, intensity, catalog) {
@@ -17540,7 +17771,7 @@ var TRIVY_BY_INTENSITY = {
 };
 function adapterPatternIds(toolId) {
   try {
-    const out = (0, import_node_child_process8.execFileSync)(
+    const out = (0, import_node_child_process9.execFileSync)(
       process.execPath,
       [setupDataPath("validate-patterns.mjs"), "--list", toolId],
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 3e4 }
@@ -17570,7 +17801,7 @@ function resolvePatternId(toolId, curatedId, adapterIds) {
 }
 function trivyPatterns(intensity) {
   try {
-    const out = (0, import_node_child_process8.execFileSync)(
+    const out = (0, import_node_child_process9.execFileSync)(
       process.execPath,
       [setupDataPath("validate-patterns.mjs"), "--emit", "Trivy", TRIVY_BY_INTENSITY[intensity].emit],
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 3e4 }
@@ -17750,7 +17981,7 @@ export default tseslint.config(
 function validatePatternIds() {
   const configPath = projectPath(CODACY_CONFIG_FILE);
   try {
-    (0, import_node_child_process8.execFileSync)(process.execPath, [setupDataPath("validate-patterns.mjs"), configPath], {
+    (0, import_node_child_process9.execFileSync)(process.execPath, [setupDataPath("validate-patterns.mjs"), configPath], {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 6e4
@@ -17767,7 +17998,7 @@ function validatePatternIds() {
 }
 async function runSynthesis(opts) {
   const standardPath = projectPath(STANDARD_FILE);
-  if ((0, import_node_fs24.existsSync)(standardPath) && !opts.force) {
+  if ((0, import_node_fs25.existsSync)(standardPath) && !opts.force) {
     return { refused: `${STANDARD_FILE} already exists \u2014 pass --force to replace it.` };
   }
   const detected = opts.detected ?? detectProject();
@@ -17895,11 +18126,11 @@ ${validation.detail}`);
 
 // src/lib/setup-state.ts
 var import_promises10 = require("node:fs/promises");
-var import_node_fs25 = require("node:fs");
+var import_node_fs26 = require("node:fs");
 var SETUP_STATE_FILE = `${VERITY_DIR}/setup.json`;
 async function readSetupState() {
   const path = projectPath(SETUP_STATE_FILE);
-  if (!(0, import_node_fs25.existsSync)(path)) return null;
+  if (!(0, import_node_fs26.existsSync)(path)) return null;
   try {
     const parsed = JSON.parse(await (0, import_promises10.readFile)(path, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : null;
@@ -17915,12 +18146,12 @@ async function writeSetupState(patch) {
 }
 
 // src/lib/push-setup.ts
-var import_node_fs27 = require("node:fs");
+var import_node_fs28 = require("node:fs");
 var import_promises11 = require("node:fs/promises");
 var import_yaml2 = __toESM(require_dist());
 
 // src/lib/verityignore.ts
-var import_node_fs26 = require("node:fs");
+var import_node_fs27 = require("node:fs");
 var EMPTY = { rules: [], securityOverlap: [], problems: [] };
 var SECURITY_PROBES = [
   ".env",
@@ -18008,14 +18239,14 @@ function decide(rules, path) {
   }
   return excluded;
 }
-function isIgnored2(ig, path) {
+function isIgnored3(ig, path) {
   return decide(ig.rules, path);
 }
 function loadVerityIgnore() {
   const file = projectPath(VERITYIGNORE_FILE);
-  if (!(0, import_node_fs26.existsSync)(file)) return EMPTY;
+  if (!(0, import_node_fs27.existsSync)(file)) return EMPTY;
   try {
-    return parseVerityIgnore((0, import_node_fs26.readFileSync)(file, "utf-8"));
+    return parseVerityIgnore((0, import_node_fs27.readFileSync)(file, "utf-8"));
   } catch {
     return EMPTY;
   }
@@ -18028,7 +18259,7 @@ function partitionIgnored(paths, ig) {
   const kept = [];
   const ignored = [];
   for (const p of paths) {
-    if (p !== VERITYIGNORE_FILE && isIgnored2(ig, p)) ignored.push(p);
+    if (p !== VERITYIGNORE_FILE && isIgnored3(ig, p)) ignored.push(p);
     else kept.push(p);
   }
   return {
@@ -18053,9 +18284,9 @@ function buildStandardUpload(standard, ignoreRaw) {
 }
 function readVerityIgnoreRaw() {
   const file = projectPath(VERITYIGNORE_FILE);
-  if (!(0, import_node_fs26.existsSync)(file)) return null;
+  if (!(0, import_node_fs27.existsSync)(file)) return null;
   try {
-    return (0, import_node_fs26.readFileSync)(file, "utf-8");
+    return (0, import_node_fs27.readFileSync)(file, "utf-8");
   } catch {
     return null;
   }
@@ -18083,7 +18314,7 @@ async function pushStandardAndConfig(globals, what = {}) {
   }
   let standardVersion = null;
   const standardPath = projectPath(STANDARD_FILE);
-  if (pushStandard && (0, import_node_fs27.existsSync)(standardPath)) {
+  if (pushStandard && (0, import_node_fs28.existsSync)(standardPath)) {
     try {
       const content = (0, import_yaml2.parse)(await (0, import_promises11.readFile)(standardPath, "utf-8"));
       const upload = buildStandardUpload(content, readVerityIgnoreRaw());
@@ -18108,7 +18339,7 @@ async function pushStandardAndConfig(globals, what = {}) {
   }
   let configPushed = false;
   const configPath = projectPath(CODACY_CONFIG_FILE);
-  if (pushConfig && (0, import_node_fs27.existsSync)(configPath)) {
+  if (pushConfig && (0, import_node_fs28.existsSync)(configPath)) {
     try {
       const content = JSON.parse(await (0, import_promises11.readFile)(configPath, "utf-8"));
       const result = await apiRequest({
@@ -18140,7 +18371,7 @@ function registerStandardCommands(program2) {
     const state = await readSetupState();
     if (opts.configOnly) {
       const standardPath = projectPath(STANDARD_FILE);
-      if (!(0, import_node_fs28.existsSync)(standardPath)) {
+      if (!(0, import_node_fs29.existsSync)(standardPath)) {
         printError(`No ${STANDARD_FILE} here \u2014 run "verity standard synthesize" to create one.`);
         process.exit(1);
       }
@@ -18471,10 +18702,10 @@ function formatRunDetail(run2) {
 }
 
 // src/lib/ignore-declaration.ts
-var import_node_fs30 = require("node:fs");
+var import_node_fs31 = require("node:fs");
 
 // src/lib/debounce.ts
-var import_node_fs29 = require("node:fs");
+var import_node_fs30 = require("node:fs");
 var import_node_crypto10 = require("node:crypto");
 function scopedFile(base, sessionId) {
   if (!sessionId) return base;
@@ -18482,9 +18713,9 @@ function scopedFile(base, sessionId) {
 }
 function checkDebounce(debounceSeconds = DEBOUNCE_SECONDS, sessionId) {
   const file = scopedFile(DEBOUNCE_FILE, sessionId);
-  if (!(0, import_node_fs29.existsSync)(file)) return null;
+  if (!(0, import_node_fs30.existsSync)(file)) return null;
   try {
-    const lastTs = parseInt((0, import_node_fs29.readFileSync)(file, "utf-8").trim(), 10);
+    const lastTs = parseInt((0, import_node_fs30.readFileSync)(file, "utf-8").trim(), 10);
     const nowTs = Math.floor(Date.now() / 1e3);
     const elapsed = nowTs - lastTs;
     if (elapsed < debounceSeconds) {
@@ -18497,10 +18728,10 @@ function checkDebounce(debounceSeconds = DEBOUNCE_SECONDS, sessionId) {
 function checkMtime(files, bypassForRecentCommits, sessionId) {
   if (bypassForRecentCommits) return null;
   const file = scopedFile(DEBOUNCE_FILE, sessionId);
-  if (!(0, import_node_fs29.existsSync)(file)) return null;
+  if (!(0, import_node_fs30.existsSync)(file)) return null;
   let debounceTime;
   try {
-    debounceTime = (0, import_node_fs29.statSync)(file).mtimeMs;
+    debounceTime = (0, import_node_fs30.statSync)(file).mtimeMs;
   } catch {
     return null;
   }
@@ -18508,7 +18739,7 @@ function checkMtime(files, bypassForRecentCommits, sessionId) {
     const resolved = resolveFile(f);
     if (!resolved) continue;
     try {
-      const stat3 = (0, import_node_fs29.statSync)(resolved);
+      const stat3 = (0, import_node_fs30.statSync)(resolved);
       if (stat3.mtimeMs > debounceTime) {
         return null;
       }
@@ -18524,8 +18755,8 @@ function computeContentHash(files) {
   for (const f of sorted) {
     const resolved = resolveFile(f) ?? f;
     try {
-      if ((0, import_node_fs29.existsSync)(resolved)) {
-        hash.update((0, import_node_fs29.readFileSync)(resolved));
+      if ((0, import_node_fs30.existsSync)(resolved)) {
+        hash.update((0, import_node_fs30.readFileSync)(resolved));
       }
     } catch {
     }
@@ -18535,9 +18766,9 @@ function computeContentHash(files) {
 function checkContentHash(files, sessionId) {
   const hash = computeContentHash(files);
   const file = scopedFile(HASH_FILE, sessionId);
-  if ((0, import_node_fs29.existsSync)(file)) {
+  if ((0, import_node_fs30.existsSync)(file)) {
     try {
-      const storedHash = (0, import_node_fs29.readFileSync)(file, "utf-8").trim();
+      const storedHash = (0, import_node_fs30.readFileSync)(file, "utf-8").trim();
       if (hash === storedHash) {
         return { skip: "No source changes since last analysis", hash };
       }
@@ -18547,24 +18778,24 @@ function checkContentHash(files, sessionId) {
   return { skip: null, hash };
 }
 function recordAnalysisStart(sessionId) {
-  (0, import_node_fs29.mkdirSync)(VERITY_DIR, { recursive: true });
-  (0, import_node_fs29.writeFileSync)(scopedFile(DEBOUNCE_FILE, sessionId), String(Math.floor(Date.now() / 1e3)));
+  (0, import_node_fs30.mkdirSync)(VERITY_DIR, { recursive: true });
+  (0, import_node_fs30.writeFileSync)(scopedFile(DEBOUNCE_FILE, sessionId), String(Math.floor(Date.now() / 1e3)));
 }
 function recordPassHash(hash, sessionId) {
-  (0, import_node_fs29.writeFileSync)(scopedFile(HASH_FILE, sessionId), hash);
+  (0, import_node_fs30.writeFileSync)(scopedFile(HASH_FILE, sessionId), hash);
 }
 function narrowToRecent(files, sessionId) {
   const file = scopedFile(DEBOUNCE_FILE, sessionId);
-  if (!(0, import_node_fs29.existsSync)(file)) return files;
+  if (!(0, import_node_fs30.existsSync)(file)) return files;
   let debounceTime;
   try {
-    debounceTime = (0, import_node_fs29.statSync)(file).mtimeMs;
+    debounceTime = (0, import_node_fs30.statSync)(file).mtimeMs;
   } catch {
     return files;
   }
   const recent = files.filter((f) => {
     try {
-      return (0, import_node_fs29.existsSync)(f) && (0, import_node_fs29.statSync)(f).mtimeMs > debounceTime;
+      return (0, import_node_fs30.existsSync)(f) && (0, import_node_fs30.statSync)(f).mtimeMs > debounceTime;
     } catch {
       return false;
     }
@@ -18577,9 +18808,9 @@ function readIteration(currentCommit, _contentHash) {
 var NO_BLOCKS = { attempts: 0, blocks: 0, fingerprint: null };
 function readBlockState(currentCommit, opts) {
   if (opts?.newUserPrompt) return NO_BLOCKS;
-  if (!(0, import_node_fs29.existsSync)(ITERATION_FILE)) return NO_BLOCKS;
+  if (!(0, import_node_fs30.existsSync)(ITERATION_FILE)) return NO_BLOCKS;
   try {
-    const stored = (0, import_node_fs29.readFileSync)(ITERATION_FILE, "utf-8").trim();
+    const stored = (0, import_node_fs30.readFileSync)(ITERATION_FILE, "utf-8").trim();
     const parsed = stored.startsWith("{") ? parseJsonState(stored) : parseLegacyState(stored);
     if (!parsed) return NO_BLOCKS;
     if (parsed.commit !== currentCommit) return NO_BLOCKS;
@@ -18625,8 +18856,8 @@ function isSameProblem(previous, current) {
   return current.split(",").some((k) => prev.has(k));
 }
 function writeBlockState(commit, state) {
-  (0, import_node_fs29.mkdirSync)(VERITY_DIR, { recursive: true });
-  (0, import_node_fs29.writeFileSync)(
+  (0, import_node_fs30.mkdirSync)(VERITY_DIR, { recursive: true });
+  (0, import_node_fs30.writeFileSync)(
     ITERATION_FILE,
     JSON.stringify({
       v: 2,
@@ -18731,9 +18962,9 @@ function resolveIgnoreState(keys) {
 }
 function readIgnoreState(sessionId) {
   const file = stateFile(sessionId);
-  if (!(0, import_node_fs30.existsSync)(file)) return null;
+  if (!(0, import_node_fs31.existsSync)(file)) return null;
   try {
-    const o = JSON.parse((0, import_node_fs30.readFileSync)(file, "utf-8")) ?? {};
+    const o = JSON.parse((0, import_node_fs31.readFileSync)(file, "utf-8")) ?? {};
     const spent = typeof o.spent === "number" ? o.spent : 0;
     const raw = o.active;
     let active = null;
@@ -18757,8 +18988,8 @@ function readIgnoreState(sessionId) {
 }
 function writeIgnoreState(state, sessionId) {
   try {
-    (0, import_node_fs30.mkdirSync)(projectPath(VERITY_DIR), { recursive: true });
-    (0, import_node_fs30.writeFileSync)(stateFile(sessionId), JSON.stringify({ v: 1, active: state.active, spent: state.spent }));
+    (0, import_node_fs31.mkdirSync)(projectPath(VERITY_DIR), { recursive: true });
+    (0, import_node_fs31.writeFileSync)(stateFile(sessionId), JSON.stringify({ v: 1, active: state.active, spent: state.spent }));
   } catch {
   }
 }
@@ -19141,10 +19372,10 @@ function createRun(opts, globals) {
 }
 
 // src/commands/analyze/index.ts
-var import_node_fs43 = require("node:fs");
+var import_node_fs44 = require("node:fs");
 
 // src/lib/repo-context.ts
-var import_node_child_process9 = require("node:child_process");
+var import_node_child_process10 = require("node:child_process");
 var import_node_os4 = require("node:os");
 function rgInvocations(env = process.env) {
   const out = [{ cmd: "rg" }];
@@ -19720,7 +19951,7 @@ function buildRepoContext(input) {
   ];
   let res = null;
   for (const inv of rgInvocations()) {
-    res = (0, import_node_child_process9.spawnSync)(inv.cmd, args, {
+    res = (0, import_node_child_process10.spawnSync)(inv.cmd, args, {
       ...inv.argv0 ? { argv0: inv.argv0 } : {},
       cwd: input.cwd ?? process.cwd(),
       timeout: input.timeoutMs ?? RG_TIMEOUT_MS,
@@ -19961,8 +20192,8 @@ function installRunEvidence(run2) {
 }
 
 // src/lib/git-frame.ts
-var import_node_child_process10 = require("node:child_process");
-var import_node_fs31 = require("node:fs");
+var import_node_child_process11 = require("node:child_process");
+var import_node_fs32 = require("node:fs");
 var import_node_os5 = require("node:os");
 var import_node_path23 = require("node:path");
 var import_node_path24 = require("node:path");
@@ -20094,21 +20325,21 @@ function parsePushTarget(segment) {
 }
 function gitAt(dir, args) {
   try {
-    return (0, import_node_child_process10.execFileSync)("git", args, { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return (0, import_node_child_process11.execFileSync)("git", args, { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
     return "";
   }
 }
 function realpathOr2(p) {
   try {
-    return import_node_fs31.realpathSync.native(p);
+    return import_node_fs32.realpathSync.native(p);
   } catch {
     return (0, import_node_path23.resolve)(p);
   }
 }
 function resolveFrame(input) {
   const found = findMomentSegment(input.command, input.on);
-  const hookDirUsable = !!input.hookCwd && (0, import_node_fs31.existsSync)(input.hookCwd);
+  const hookDirUsable = !!input.hookCwd && (0, import_node_fs32.existsSync)(input.hookCwd);
   const baseDir = hookDirUsable ? input.hookCwd : process.cwd();
   let anchor = hookDirUsable ? "hook-cwd" : "process-cwd";
   const refuse = (refusal) => ({
@@ -20131,7 +20362,7 @@ function resolveFrame(input) {
     if (dirs.size > 1) return refuse(`target:multiple ${found.moment} targets in one command`);
     const targetDir = dirs.size === 1 ? [...dirs][0] : baseDir;
     if (targetDir !== baseDir) {
-      if (!(0, import_node_fs31.existsSync)(targetDir)) return refuse(`target:directory does not exist: ${targetDir}`);
+      if (!(0, import_node_fs32.existsSync)(targetDir)) return refuse(`target:directory does not exist: ${targetDir}`);
       dir = targetDir;
     }
   }
@@ -20318,7 +20549,7 @@ function stagedRange(frame, command) {
     return { kind: "staged", base: "HEAD", head: "INDEX", via: "staged-in-command", refusal: plan.reason };
   }
   const mergeHead = frame.gitDir ? (0, import_node_path24.join)(frame.gitDir, "MERGE_HEAD") : null;
-  if (mergeHead && (0, import_node_fs31.existsSync)(mergeHead)) {
+  if (mergeHead && (0, import_node_fs32.existsSync)(mergeHead)) {
     const vsHead = new Set(frameGit(frame, ["diff", "--cached", "--name-only", "HEAD"]).split("\n").filter(Boolean));
     const vsMerge = new Set(frameGit(frame, ["diff", "--cached", "--name-only", "MERGE_HEAD"]).split("\n").filter(Boolean));
     const resolutions = new Set([...vsHead].filter((f) => vsMerge.has(f) && !isVerityOwnedPath(f)));
@@ -20452,7 +20683,7 @@ function truthy(v) {
 }
 
 // src/lib/transcript.ts
-var import_node_fs32 = require("node:fs");
+var import_node_fs33 = require("node:fs");
 var MAX_READ_BYTES = 256 * 1024;
 var SMALL_FILE_BYTES = 64 * 1024;
 var MAX_FILES_LIST = 20;
@@ -20479,7 +20710,7 @@ async function extractActionSummary(transcriptPath) {
 function readTurnLines(transcriptPath) {
   let size;
   try {
-    size = (0, import_node_fs32.statSync)(transcriptPath).size;
+    size = (0, import_node_fs33.statSync)(transcriptPath).size;
   } catch {
     return null;
   }
@@ -20487,7 +20718,7 @@ function readTurnLines(transcriptPath) {
   let raw;
   let windowed = false;
   if (size <= SMALL_FILE_BYTES) {
-    raw = (0, import_node_fs32.readFileSync)(transcriptPath, "utf-8");
+    raw = (0, import_node_fs33.readFileSync)(transcriptPath, "utf-8");
   } else {
     windowed = true;
     const buf = Buffer.alloc(Math.min(MAX_READ_BYTES, size));
@@ -20995,7 +21226,7 @@ function channelSilence(input) {
 // src/lib/cli-version.ts
 function cliVersion() {
   try {
-    return true ? "0.32.5-experimental.4d91ca0" : "dev";
+    return true ? "0.32.6" : "dev";
   } catch {
     return "dev";
   }
@@ -21035,8 +21266,8 @@ async function sendSkipBeacon(ctx, reason) {
 }
 
 // src/lib/static-analysis.ts
-var import_node_child_process11 = require("node:child_process");
-var import_node_fs33 = require("node:fs");
+var import_node_child_process12 = require("node:child_process");
+var import_node_fs34 = require("node:fs");
 var SEVERITY_ORDER = {
   Error: 0,
   Critical: 0,
@@ -21048,7 +21279,7 @@ var SEVERITY_ORDER = {
 };
 function isCodacyAvailable() {
   try {
-    (0, import_node_child_process11.execSync)("which codacy-analysis", { stdio: "pipe" });
+    (0, import_node_child_process12.execSync)("which codacy-analysis", { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -21084,13 +21315,13 @@ function runCodacyAnalysis(files) {
   if (files.length === 0) return empty;
   const existingFiles = files.filter((f) => {
     try {
-      return (0, import_node_fs33.existsSync)(f);
+      return (0, import_node_fs34.existsSync)(f);
     } catch {
       return false;
     }
   });
   if (existingFiles.length === 0) return empty;
-  const proc = (0, import_node_child_process11.spawnSync)("codacy-analysis", buildAnalyzerArgv(existingFiles), {
+  const proc = (0, import_node_child_process12.spawnSync)("codacy-analysis", buildAnalyzerArgv(existingFiles), {
     encoding: "utf-8",
     maxBuffer: 10 * 1024 * 1024
   });
@@ -21353,7 +21584,7 @@ async function scope(run2) {
 }
 
 // src/lib/specs.ts
-var import_node_fs34 = require("node:fs");
+var import_node_fs35 = require("node:fs");
 var import_node_path25 = require("node:path");
 var SPEC_CANDIDATES = [
   "CLAUDE.md",
@@ -21385,16 +21616,16 @@ function discoverSpecs(consulted = []) {
     const totalCap = relevant ? MAX_TOTAL_SPEC_BYTES : UNCONSULTED_TOTAL_BYTES;
     if (totalBytes >= totalCap) return false;
     if (seen.has(specPath)) return true;
-    if (!(0, import_node_fs34.existsSync)(specPath)) return true;
+    if (!(0, import_node_fs35.existsSync)(specPath)) return true;
     seen.add(specPath);
     const remaining = totalCap - totalBytes;
     const fileCap = relevant ? MAX_SPEC_FILE_BYTES : UNCONSULTED_FILE_BYTES;
     const readBytes = Math.min(fileCap, remaining);
     try {
       const buf = Buffer.alloc(readBytes);
-      const fd = (0, import_node_fs34.openSync)(specPath, "r");
-      const bytesRead = (0, import_node_fs34.readSync)(fd, buf, 0, readBytes, 0);
-      (0, import_node_fs34.closeSync)(fd);
+      const fd = (0, import_node_fs35.openSync)(specPath, "r");
+      const bytesRead = (0, import_node_fs35.readSync)(fd, buf, 0, readBytes, 0);
+      (0, import_node_fs35.closeSync)(fd);
       const content = buf.slice(0, bytesRead).toString("utf-8");
       if (!content) return true;
       result.push({ path: specPath, content });
@@ -21410,7 +21641,7 @@ function discoverSpecs(consulted = []) {
     if (!addSpec(candidate)) break;
   }
   for (const dir of ["spec", "docs"]) {
-    if (!(0, import_node_fs34.existsSync)(dir)) continue;
+    if (!(0, import_node_fs35.existsSync)(dir)) continue;
     try {
       const mdFiles = findMdFiles(dir, 2).sort();
       for (const mdFile of mdFiles) {
@@ -21425,7 +21656,7 @@ function findMdFiles(dir, maxDepth, depth = 0) {
   if (depth >= maxDepth) return [];
   const result = [];
   try {
-    const entries = (0, import_node_fs34.readdirSync)(dir, { withFileTypes: true });
+    const entries = (0, import_node_fs35.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = (0, import_node_path25.join)(dir, entry.name);
       if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -21444,14 +21675,14 @@ function discoverPlans() {
   const candidates2 = [];
   const seen = /* @__PURE__ */ new Set();
   for (const plansDir of [localPlansDir, homePlansDir]) {
-    if (!(0, import_node_fs34.existsSync)(plansDir)) continue;
+    if (!(0, import_node_fs35.existsSync)(plansDir)) continue;
     try {
-      for (const f of (0, import_node_fs34.readdirSync)(plansDir)) {
+      for (const f of (0, import_node_fs35.readdirSync)(plansDir)) {
         if (!f.endsWith(".md") || seen.has(f)) continue;
         seen.add(f);
         const fullPath = (0, import_node_path25.join)(plansDir, f);
         try {
-          const stat3 = (0, import_node_fs34.statSync)(fullPath);
+          const stat3 = (0, import_node_fs35.statSync)(fullPath);
           candidates2.push({ name: f, path: fullPath, mtime: stat3.mtimeMs, size: stat3.size });
         } catch {
         }
@@ -21464,7 +21695,7 @@ function discoverPlans() {
   for (const entry of candidates2.slice(0, MAX_PLAN_FILES)) {
     if (entry.size > MAX_PLAN_FILE_BYTES) continue;
     try {
-      const content = (0, import_node_fs34.readFileSync)(entry.path, "utf-8");
+      const content = (0, import_node_fs35.readFileSync)(entry.path, "utf-8");
       result.push({ name: entry.name, content });
     } catch {
     }
@@ -21479,12 +21710,12 @@ function discoverGuardDocs(rangeFiles2) {
     if (result.length >= MAX_SPEC_FILES) break;
     if (!GUARD_DOC_EXT.test(path)) continue;
     if (path.startsWith("/") || path.includes("..")) continue;
-    if (!(0, import_node_fs34.existsSync)(path)) continue;
+    if (!(0, import_node_fs35.existsSync)(path)) continue;
     try {
-      const stat3 = (0, import_node_fs34.statSync)(path);
+      const stat3 = (0, import_node_fs35.statSync)(path);
       if (stat3.size > MAX_PLAN_FILE_BYTES) continue;
       if (totalBytes + stat3.size > MAX_TOTAL_SPEC_BYTES) continue;
-      const content = (0, import_node_fs34.readFileSync)(path, "utf-8");
+      const content = (0, import_node_fs35.readFileSync)(path, "utf-8");
       if (!content) continue;
       result.push({ name: path, content });
       totalBytes += content.length;
@@ -21660,7 +21891,7 @@ async function mode(run2) {
 }
 
 // src/lib/fold.ts
-var import_node_fs35 = require("node:fs");
+var import_node_fs36 = require("node:fs");
 var import_node_path26 = require("node:path");
 var KNOWN_RECORD_TYPES = /* @__PURE__ */ new Set([
   "user",
@@ -21798,7 +22029,7 @@ function candidateRoots(repoRoot2) {
   const norm = repoRoot2.replace(/\\/g, "/").replace(/\/+$/, "");
   const out = [norm];
   try {
-    const real = import_node_fs35.realpathSync.native(norm).replace(/\\/g, "/").replace(/\/+$/, "");
+    const real = import_node_fs36.realpathSync.native(norm).replace(/\\/g, "/").replace(/\/+$/, "");
     if (real !== norm) out.push(real);
   } catch {
   }
@@ -21886,8 +22117,8 @@ function fold(transcriptPath, opts = {}) {
     }
   };
   try {
-    if (!(0, import_node_fs35.existsSync)(transcriptPath)) return result;
-    ingest((0, import_node_fs35.readFileSync)(transcriptPath, "utf8"), "agent");
+    if (!(0, import_node_fs36.existsSync)(transcriptPath)) return result;
+    ingest((0, import_node_fs36.readFileSync)(transcriptPath, "utf8"), "agent");
     result.coverage.complete = true;
   } catch {
     return result;
@@ -21898,19 +22129,19 @@ function fold(transcriptPath, opts = {}) {
       (0, import_node_path26.basename)(transcriptPath).replace(/\.jsonl$/, ""),
       "subagents"
     );
-    if ((0, import_node_fs35.existsSync)(sidecarDir)) {
+    if ((0, import_node_fs36.existsSync)(sidecarDir)) {
       const maxFiles = opts.maxSidecars ?? 200;
       const maxBytes = opts.maxSidecarBytes ?? 16 * 1024 * 1024;
       const found = [];
       const walk2 = (d, depth) => {
         if (depth > 4) return;
-        for (const e of (0, import_node_fs35.readdirSync)(d, { withFileTypes: true })) {
+        for (const e of (0, import_node_fs36.readdirSync)(d, { withFileTypes: true })) {
           const p = (0, import_node_path26.join)(d, e.name);
           if (e.isDirectory()) {
             walk2(p, depth + 1);
           } else if (e.name.startsWith("agent-") && e.name.endsWith(".jsonl")) {
             try {
-              const st = (0, import_node_fs35.statSync)(p);
+              const st = (0, import_node_fs36.statSync)(p);
               found.push({ path: p, size: st.size, mtimeMs: st.mtimeMs });
             } catch {
               result.coverage.malformed++;
@@ -21927,7 +22158,7 @@ function fold(transcriptPath, opts = {}) {
           continue;
         }
         try {
-          ingest((0, import_node_fs35.readFileSync)(f.path, "utf8"), "subagent");
+          ingest((0, import_node_fs36.readFileSync)(f.path, "utf8"), "subagent");
           bytes += f.size;
           result.coverage.subagentFiles++;
         } catch {
@@ -21962,7 +22193,7 @@ function fold(transcriptPath, opts = {}) {
 }
 function classifyUnobserved(path) {
   try {
-    const st = (0, import_node_fs35.statSync)(path);
+    const st = (0, import_node_fs36.statSync)(path);
     if (!st.isFile()) return "unreadable";
   } catch {
     return "unreadable";
@@ -22279,20 +22510,20 @@ async function evidence(run2) {
 }
 
 // src/lib/cache-cleanup.ts
-var import_node_fs36 = require("node:fs");
+var import_node_fs37 = require("node:fs");
 var import_node_path27 = require("node:path");
 var CACHE_TTL_DAYS = 7;
 function pruneStaleCache() {
   try {
     const dir = projectPath(CACHE_DIR);
     const cutoff = Date.now() - CACHE_TTL_DAYS * 24 * 3600 * 1e3;
-    for (const entry of (0, import_node_fs36.readdirSync)(dir)) {
+    for (const entry of (0, import_node_fs37.readdirSync)(dir)) {
       if (!entry.startsWith("pending-")) continue;
       const path = (0, import_node_path27.join)(dir, entry);
       try {
-        const stat3 = (0, import_node_fs36.statSync)(path);
+        const stat3 = (0, import_node_fs37.statSync)(path);
         if (stat3.mtimeMs < cutoff) {
-          (0, import_node_fs36.unlinkSync)(path);
+          (0, import_node_fs37.unlinkSync)(path);
           logEvent("cache_entry_pruned", {
             path: entry,
             age_days: Math.round((Date.now() - stat3.mtimeMs) / 864e5)
@@ -22306,7 +22537,7 @@ function pruneStaleCache() {
 }
 
 // src/lib/context-files.ts
-var import_node_fs37 = require("node:fs");
+var import_node_fs38 = require("node:fs");
 var import_node_os6 = require("node:os");
 var MAX_CONTEXT_FILES = 10;
 var MAX_CONTEXT_FILE_BYTES = 10240;
@@ -22364,7 +22595,7 @@ function gatherContextFiles(contextPaths, deltaFiles, opts) {
       continue;
     }
     try {
-      const content = (0, import_node_fs37.readFileSync)(safePath, "utf8");
+      const content = (0, import_node_fs38.readFileSync)(safePath, "utf8");
       const bytes = Buffer.byteLength(content);
       if (bytes > MAX_CONTEXT_FILE_BYTES) {
         logEvent("context_file_skipped", { path: filePath, reason: "too_large", bytes });
@@ -22414,7 +22645,7 @@ async function contextFiles(run2) {
   const readSet = readSetContextPaths(run2.actionSummary, codeDelta.files);
   const { kept: externalContext } = partitionVerityOwned(readSet);
   const ig = loadVerityIgnore();
-  const unfenced = run2.verityIgnored.suspended ? externalContext : externalContext.filter((p) => !isIgnored2(ig, p));
+  const unfenced = run2.verityIgnored.suspended ? externalContext : externalContext.filter((p) => !isIgnored3(ig, p));
   const contextFiles2 = gatherContextFiles(unfenced, codeDelta.files, {
     maxFiles: MAX_FILES - codeDelta.files.length
   });
@@ -22435,7 +22666,7 @@ async function repoContext(run2) {
   const deltaFiles = codeDelta.files.filter((f) => f.role !== "context");
   const sentPaths = new Set(codeDelta.files.map((f) => f.path));
   const ig = loadVerityIgnore();
-  const isExcluded = (p) => isVerityOwnedPath(p) || !run2.verityIgnored.suspended && isIgnored2(ig, p);
+  const isExcluded = (p) => isVerityOwnedPath(p) || !run2.verityIgnored.suspended && isIgnored3(ig, p);
   run2.repoContext = buildRepoContext({
     deltaFiles,
     diffs: snapshotResult.diffs,
@@ -22455,7 +22686,7 @@ async function repoContext(run2) {
 
 // src/lib/seed-runner.ts
 var import_promises14 = require("node:fs/promises");
-var import_node_fs38 = require("node:fs");
+var import_node_fs39 = require("node:fs");
 var import_node_path28 = require("node:path");
 var import_yaml4 = __toESM(require_dist());
 
@@ -22695,7 +22926,7 @@ function renderNodeMarkdown(candidate, nodeId, createdAt) {
   return fm;
 }
 async function runSeed(opts) {
-  if (!(0, import_node_fs38.existsSync)(STANDARD_FILE)) {
+  if (!(0, import_node_fs39.existsSync)(STANDARD_FILE)) {
     return { created: 0, failed: 0, skipped: "no_standard", candidates: [] };
   }
   let standardDoc;
@@ -22707,7 +22938,7 @@ async function runSeed(opts) {
   }
   const knowledgeSpec = standardDoc.knowledge_spec ?? {};
   let readmeContent;
-  if ((0, import_node_fs38.existsSync)("README.md")) {
+  if ((0, import_node_fs39.existsSync)("README.md")) {
     try {
       readmeContent = await (0, import_promises14.readFile)("README.md", "utf-8");
     } catch {
@@ -22715,7 +22946,7 @@ async function runSeed(opts) {
   }
   let claudeMdContent;
   for (const p of ["CLAUDE.md", ".claude/CLAUDE.md"]) {
-    if ((0, import_node_fs38.existsSync)(p)) {
+    if ((0, import_node_fs39.existsSync)(p)) {
       try {
         claudeMdContent = await (0, import_promises14.readFile)(p, "utf-8");
         break;
@@ -22739,7 +22970,7 @@ async function runSeed(opts) {
     return { created: 0, failed: 0, skipped: "no_candidates", candidates: [] };
   }
   const overviewPath = (0, import_node_path28.join)(MEMORY_DIR, "domain", "project-overview.md");
-  if ((0, import_node_fs38.existsSync)(overviewPath) && !opts.force) {
+  if ((0, import_node_fs39.existsSync)(overviewPath) && !opts.force) {
     return { created: 0, failed: 0, skipped: "already_seeded", candidates: candidates2 };
   }
   if (opts.dryRun) {
@@ -22794,7 +23025,7 @@ async function runSeed(opts) {
 }
 
 // src/commands/analyze/phases/08-memory-manifest.ts
-var import_node_fs39 = require("node:fs");
+var import_node_fs40 = require("node:fs");
 var import_node_path29 = require("node:path");
 async function memoryManifest(run2) {
   const { globals } = run2;
@@ -22806,8 +23037,8 @@ async function memoryManifest(run2) {
   try {
     await ensureMemoryDir();
     const seedMarker = (0, import_node_path29.join)(VERITY_DIR, ".seeded");
-    const hasStandard = (0, import_node_fs39.existsSync)(STANDARD_FILE);
-    const alreadyTried = (0, import_node_fs39.existsSync)(seedMarker);
+    const hasStandard = (0, import_node_fs40.existsSync)(STANDARD_FILE);
+    const alreadyTried = (0, import_node_fs40.existsSync)(seedMarker);
     if (hasStandard && !alreadyTried) {
       const preManifest = await buildManifest();
       if (preManifest.nodes.length === 0) {
@@ -22820,7 +23051,7 @@ async function memoryManifest(run2) {
             dryRun: false
           });
           if (seedResult.created > 0) {
-            (0, import_node_fs39.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} created=${seedResult.created}
+            (0, import_node_fs40.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} created=${seedResult.created}
 `);
             autoSeedNotice = `Seeded ${seedResult.created} knowledge node(s) from your existing Standard (one-time).`;
             logEvent("auto_seed_ran", {
@@ -22828,7 +23059,7 @@ async function memoryManifest(run2) {
               failed: seedResult.failed
             });
           } else if (seedResult.skipped === "already_seeded") {
-            (0, import_node_fs39.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} skipped=already_seeded
+            (0, import_node_fs40.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} skipped=already_seeded
 `);
           } else {
             logEvent("auto_seed_noop", {
@@ -23017,7 +23248,7 @@ async function workingMemory(run2) {
 }
 
 // src/lib/note-budget.ts
-var import_node_fs40 = require("node:fs");
+var import_node_fs41 = require("node:fs");
 var ADVISORY_BUDGET = { PASS: 1, WARN: 2 };
 var EPISODE_STALE_SECONDS = 30 * 60;
 var FRESH = { delivered: 0, tasksCompleted: 0, ts: 0 };
@@ -23039,9 +23270,9 @@ function advisoryBudgetSpent(episode, rawDecision) {
 }
 function readAdvisoryEpisode(sessionId) {
   const file = scopedFile(ADVISORY_EPISODE_FILE, sessionId);
-  if (!(0, import_node_fs40.existsSync)(file)) return null;
+  if (!(0, import_node_fs41.existsSync)(file)) return null;
   try {
-    const o = JSON.parse((0, import_node_fs40.readFileSync)(file, "utf-8")) ?? {};
+    const o = JSON.parse((0, import_node_fs41.readFileSync)(file, "utf-8")) ?? {};
     const delivered = typeof o.delivered === "number" ? o.delivered : NaN;
     if (isNaN(delivered)) return null;
     return {
@@ -23055,8 +23286,8 @@ function readAdvisoryEpisode(sessionId) {
 }
 function writeAdvisoryEpisode(episode, sessionId) {
   try {
-    (0, import_node_fs40.mkdirSync)(VERITY_DIR, { recursive: true });
-    (0, import_node_fs40.writeFileSync)(
+    (0, import_node_fs41.mkdirSync)(VERITY_DIR, { recursive: true });
+    (0, import_node_fs41.writeFileSync)(
       scopedFile(ADVISORY_EPISODE_FILE, sessionId),
       JSON.stringify({ v: 1, ...episode })
     );
@@ -23086,7 +23317,7 @@ function isExplicitlyAutonomous(env = process.env) {
 }
 
 // src/lib/task-context.ts
-var import_node_child_process12 = require("node:child_process");
+var import_node_child_process13 = require("node:child_process");
 var CLOSING_RE = /\b(close[sd]?|fix(?:e[sd])?|resolve[sd]?)\b[\s:]*#(\d+)/i;
 var BRANCH_RE = /(?:^|[/_-])(?:issue|gh|fix)[-_/]?(\d+)\b/i;
 function parseLinkedIssue(sources) {
@@ -23102,7 +23333,7 @@ function parseLinkedIssue(sources) {
 }
 function safeExec(cmd, timeout) {
   try {
-    return (0, import_node_child_process12.execSync)(cmd, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout }).trim();
+    return (0, import_node_child_process13.execSync)(cmd, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout }).trim();
   } catch {
     return "";
   }
@@ -23373,14 +23604,14 @@ async function buildRequest(run2) {
 }
 
 // src/lib/offline.ts
-var import_node_fs41 = require("node:fs");
+var import_node_fs42 = require("node:fs");
 var import_node_crypto11 = require("node:crypto");
 function cacheRequest(body) {
   try {
-    (0, import_node_fs41.mkdirSync)(CACHE_DIR, { recursive: true });
+    (0, import_node_fs42.mkdirSync)(CACHE_DIR, { recursive: true });
     const suffix = (0, import_node_crypto11.randomBytes)(4).toString("hex");
     const filename = `pending-${Math.floor(Date.now() / 1e3)}-${suffix}.json`;
-    (0, import_node_fs41.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(redactRequest(body)));
+    (0, import_node_fs42.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(redactRequest(body)));
   } catch {
   }
 }
@@ -23499,7 +23730,7 @@ async function transmit(run2) {
 }
 
 // src/commands/analyze/phases/13-reconcile.ts
-var import_node_fs42 = require("node:fs");
+var import_node_fs43 = require("node:fs");
 var import_node_path31 = require("node:path");
 async function reconcile(run2) {
   const { actionSummary, allChanged, analyzable, baseline, baselineSessionId, codeDelta, contentHash, conversation, decision, foldResult, memory, memorySession, response, reviewable, securityFiles, turnId } = run2;
@@ -23529,7 +23760,7 @@ async function reconcile(run2) {
       const st = foldDossier(memorySession.d);
       openElsewhere = openBlockingElsewhere(st.statements, sentPaths, (file, line) => {
         try {
-          const src = (0, import_node_fs42.readFileSync)((0, import_node_path31.join)(repoRoot(), file), "utf8").split("\n");
+          const src = (0, import_node_fs43.readFileSync)((0, import_node_path31.join)(repoRoot(), file), "utf8").split("\n");
           const at = src[line - 1];
           return at === void 0 ? null : lineSha(at);
         } catch {
@@ -24194,7 +24425,7 @@ function registerAnalyzeCommand(program2) {
 var tracing = () => process.env.VERITY_TRACE_PHASES === "1";
 async function runAnalyze(opts, globals) {
   if (!verityConfigured()) {
-    (0, import_node_fs43.writeSync)(2, '[verity] not set up in this project \u2014 run "verity init" first.\n');
+    (0, import_node_fs44.writeSync)(2, '[verity] not set up in this project \u2014 run "verity init" first.\n');
     process.exit(0);
   }
   const run2 = createRun(opts, globals);
@@ -24214,8 +24445,11 @@ async function runAnalyze(opts, globals) {
   }
 }
 
+// src/commands/baseline.ts
+var import_node_fs46 = require("node:fs");
+
 // src/lib/project-skills.ts
-var import_node_fs44 = require("node:fs");
+var import_node_fs45 = require("node:fs");
 var import_node_path32 = require("node:path");
 var PROJECT_SKILL_NAMES = [
   "verity-setup",
@@ -24241,14 +24475,14 @@ var LEGACY_SKILL_NAMES = [
 var ALL = [...PROJECT_SKILL_NAMES, ...LEGACY_SKILL_NAMES];
 function staleProjectSkills() {
   const root = projectPath(".claude/skills");
-  if (!(0, import_node_fs44.existsSync)(root)) return [];
-  return ALL.filter((name) => (0, import_node_fs44.existsSync)((0, import_node_path32.join)(root, name)));
+  if (!(0, import_node_fs45.existsSync)(root)) return [];
+  return ALL.filter((name) => (0, import_node_fs45.existsSync)((0, import_node_path32.join)(root, name)));
 }
 function removeProjectSkills() {
   const root = projectPath(".claude/skills");
   const removed = [];
   for (const name of staleProjectSkills()) {
-    (0, import_node_fs44.rmSync)((0, import_node_path32.join)(root, name), { recursive: true, force: true });
+    (0, import_node_fs45.rmSync)((0, import_node_path32.join)(root, name), { recursive: true, force: true });
     removed.push(name);
   }
   return removed;
@@ -24310,6 +24544,20 @@ function registerBaselineCommands(program2) {
         process.exit(0);
       }
       const realStart = source === void 0 || source === "startup" || source === "clear";
+      let memoryMsg = null;
+      let memoryAgentLine = null;
+      const memoryNotice = projectPath(`${VERITY_DIR}/.memory-fence-notice`);
+      if (realStart && !(0, import_node_fs46.existsSync)(memoryNotice)) {
+        const trackedGraph = memoryOptOut() ? 0 : committedMemoryFiles().length;
+        if (trackedGraph > 0) {
+          memoryMsg = `Verity: this project commits its knowledge base (${trackedGraph} files under .verity/memory/), so Verity's generated notes show up in every diff and pull request. Run \`verity memory untrack\` to keep them on disk but out of git, or \`verity memory track\` to keep committing them on purpose.`;
+          memoryAgentLine = `This project has ${trackedGraph} knowledge-graph files tracked in git under .verity/memory/. As of Verity 0.32.6 the graph is machine-local by default \u2014 it is rebuilt from the service, and committing it puts generated notes in every pull request. If the user wants that stopped, run \`verity memory untrack\` for them: it keeps every file on disk and stages their removal from the index, so they only need to commit \u2014 and their teammates' working copies will vanish on the next pull and re-sync from the service, which is expected. If they would rather keep committing it, \`verity memory track\` records that and nothing will offer again.`;
+          try {
+            (0, import_node_fs46.writeFileSync)(memoryNotice, (/* @__PURE__ */ new Date()).toISOString() + "\n");
+          } catch {
+          }
+        }
+      }
       if (isPluginInvocation() && realStart) {
         const installed2 = activePluginVersion();
         const state = await readSetupState().catch(() => null);
@@ -24332,10 +24580,11 @@ function registerBaselineCommands(program2) {
             );
           }
         }
+        if (memoryAgentLine) notices.push(memoryAgentLine);
         if (notices.length > 0) {
           process.stdout.write(
             JSON.stringify({
-              ...userMsg || skewMsg ? { systemMessage: [skewMsg, userMsg].filter(Boolean).join("\n") } : {},
+              ...userMsg || skewMsg || memoryMsg ? { systemMessage: [skewMsg, userMsg, memoryMsg].filter(Boolean).join("\n") } : {},
               hookSpecificOutput: {
                 hookEventName: "SessionStart",
                 additionalContext: notices.join("\n")
@@ -24343,6 +24592,16 @@ function registerBaselineCommands(program2) {
             }) + "\n"
           );
         }
+      } else if (memoryMsg) {
+        process.stdout.write(
+          JSON.stringify({
+            systemMessage: memoryMsg,
+            hookSpecificOutput: {
+              hookEventName: "SessionStart",
+              ...memoryAgentLine ? { additionalContext: memoryAgentLine } : {}
+            }
+          }) + "\n"
+        );
       }
       if (deferredToPlugin("baseline capture", session ?? null)) {
         process.exit(0);
@@ -24394,7 +24653,7 @@ function hookSource(value) {
 }
 
 // src/commands/review.ts
-var import_node_fs45 = require("node:fs");
+var import_node_fs47 = require("node:fs");
 function registerReviewCommand(program2) {
   program2.command("review").description("Run on-demand Verity analysis (advisory, never blocks)").requiredOption("--files <paths>", "Comma-separated file list").option("--changed <paths>", "Subset of --files that were modified").option("--intent <text>", "User intent description (max 2000 chars)").option("--specs <paths>", "Comma-separated spec file paths").option("--json", "Output raw JSON response").action(async (opts) => {
     const globals = program2.opts();
@@ -24413,7 +24672,7 @@ async function runReview(opts, globals) {
   const securityFiles = filterSecurity(allFiles);
   let staticResults;
   if (isCodacyAvailable()) {
-    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).filter((f) => (0, import_node_fs45.existsSync)(f) || resolveFile(f) !== null);
+    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).filter((f) => (0, import_node_fs47.existsSync)(f) || resolveFile(f) !== null);
     staticResults = runCodacyAnalysis(scannable);
   } else {
     staticResults = {
@@ -24439,7 +24698,7 @@ async function runReview(opts, globals) {
     const specPaths = opts.specs.split(",").map((f) => f.trim()).filter(Boolean);
     specs = [];
     for (const p of specPaths) {
-      if (!(0, import_node_fs45.existsSync)(p)) continue;
+      if (!(0, import_node_fs47.existsSync)(p)) continue;
       try {
         const { readFileSync: readFileSync27 } = await import("node:fs");
         const content = readFileSync27(p, "utf-8");
@@ -24499,7 +24758,7 @@ async function runReview(opts, globals) {
 }
 
 // src/commands/guard.ts
-var import_node_fs46 = require("node:fs");
+var import_node_fs48 = require("node:fs");
 var import_node_path33 = require("node:path");
 var GUARD_BLOCK_CAP = 2;
 var GUARD_ITER_FILE = (0, import_node_path33.join)(VERITY_DIR, ".guard-iteration");
@@ -24547,7 +24806,7 @@ function readPreToolUseStdin() {
 }
 function readIterMap() {
   try {
-    const raw = JSON.parse((0, import_node_fs46.readFileSync)(GUARD_ITER_FILE, "utf-8"));
+    const raw = JSON.parse((0, import_node_fs48.readFileSync)(GUARD_ITER_FILE, "utf-8"));
     if (raw && typeof raw === "object") {
       if (typeof raw.moment === "string" && typeof raw.count === "number") {
         return { [raw.moment]: raw.count };
@@ -24567,10 +24826,10 @@ function readIter(moment) {
 }
 function writeIter(moment, count) {
   try {
-    (0, import_node_fs46.mkdirSync)(VERITY_DIR, { recursive: true });
+    (0, import_node_fs48.mkdirSync)(VERITY_DIR, { recursive: true });
     const map = readIterMap();
     map[moment] = count;
-    (0, import_node_fs46.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
+    (0, import_node_fs48.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
   } catch {
   }
 }
@@ -24580,10 +24839,10 @@ function resetIter(moment) {
     if (!(moment in map)) return;
     delete map[moment];
     if (Object.keys(map).length === 0) {
-      if ((0, import_node_fs46.existsSync)(GUARD_ITER_FILE)) (0, import_node_fs46.unlinkSync)(GUARD_ITER_FILE);
+      if ((0, import_node_fs48.existsSync)(GUARD_ITER_FILE)) (0, import_node_fs48.unlinkSync)(GUARD_ITER_FILE);
     } else {
-      (0, import_node_fs46.mkdirSync)(VERITY_DIR, { recursive: true });
-      (0, import_node_fs46.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
+      (0, import_node_fs48.mkdirSync)(VERITY_DIR, { recursive: true });
+      (0, import_node_fs48.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
     }
   } catch {
   }
@@ -24655,7 +24914,7 @@ function buildGuardRequest(moment, files, codeDelta, iter, sessionId, statedInte
   const securityFiles = filterSecurity(files);
   let staticResults;
   if (isCodacyAvailable()) {
-    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).map((f) => (0, import_node_fs46.existsSync)(f) ? f : resolveFile(f)).filter((f) => f !== null);
+    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).map((f) => (0, import_node_fs48.existsSync)(f) ? f : resolveFile(f)).filter((f) => f !== null);
     staticResults = runCodacyAnalysis(scannable);
   } else {
     staticResults = { tool: "@codacy/analysis-cli", findings: [], summary: { total_findings: 0, by_severity: {}, tools_run: [] } };
@@ -24795,13 +25054,13 @@ async function runGuard(opts, globals) {
       diffs: [],
       signalsByPath: rangeChangeSignals(frame, range, codeDelta.files.map((f) => f.path)),
       sentPaths: new Set(codeDelta.files.map((f) => f.path)),
-      isExcluded: (p) => isVerityOwnedPath(p) || isIgnored2(ig, p),
+      isExcluded: (p) => isVerityOwnedPath(p) || isIgnored3(ig, p),
       cwd: frame.worktreeRoot ?? process.cwd()
     });
     upgradeToExcerpts(repoContext2, {
       readFile: (rel) => {
         try {
-          return (0, import_node_fs46.readFileSync)((0, import_node_path33.join)(frame.worktreeRoot ?? process.cwd(), rel), "utf8");
+          return (0, import_node_fs48.readFileSync)((0, import_node_path33.join)(frame.worktreeRoot ?? process.cwd(), rel), "utf8");
         } catch {
           return null;
         }
@@ -25043,7 +25302,7 @@ function registerIgnoreCommand(program2) {
 
 // src/commands/waive.ts
 var import_node_crypto12 = require("node:crypto");
-var import_node_fs47 = require("node:fs");
+var import_node_fs49 = require("node:fs");
 function registerWaiveCommand(program2) {
   program2.command("waive <pattern-id>").description("Record an accepted-risk disposition for an open finding (voids when the file changes)").option("--file <path>", "File the finding is anchored to, REPO-RELATIVE (recommended \u2014 narrows the waive)").requiredOption("--reason <text>", "The human disposition this records (reviewer finding, ADR, \u2026)").action(async (patternId, opts) => {
     const globals = program2.opts();
@@ -25072,7 +25331,7 @@ function registerWaiveCommand(program2) {
     if (opts.file) {
       body.file = opts.file;
       try {
-        body.file_sha256 = (0, import_node_crypto12.createHash)("sha256").update((0, import_node_fs47.readFileSync)(opts.file)).digest("hex");
+        body.file_sha256 = (0, import_node_crypto12.createHash)("sha256").update((0, import_node_fs49.readFileSync)(opts.file)).digest("hex");
       } catch {
         printError(`Cannot read ${opts.file} \u2014 run from the repo root, or omit --file to waive by pattern.`);
         process.exit(1);
@@ -25097,7 +25356,7 @@ function registerWaiveCommand(program2) {
 }
 
 // src/commands/init.ts
-var import_node_fs52 = require("node:fs");
+var import_node_fs53 = require("node:fs");
 var import_promises17 = require("node:fs/promises");
 var import_yaml6 = __toESM(require_dist());
 var import_node_path36 = require("node:path");
@@ -25179,14 +25438,14 @@ function printPhase(n, of, title, subtitle) {
 }
 
 // src/commands/doctor.ts
-var import_node_fs49 = require("node:fs");
+var import_node_fs50 = require("node:fs");
 
 // src/lib/prereqs.ts
-var import_node_child_process13 = require("node:child_process");
+var import_node_child_process14 = require("node:child_process");
 var MIN_NODE_MAJOR = 20;
 function which(bin) {
   try {
-    const out = (0, import_node_child_process13.execSync)(`command -v ${bin}`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const out = (0, import_node_child_process14.execSync)(`command -v ${bin}`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     return out || null;
   } catch {
     return null;
@@ -25208,7 +25467,7 @@ function checkNode() {
 function checkGit() {
   let detail = "";
   try {
-    detail = (0, import_node_child_process13.execSync)("git --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    detail = (0, import_node_child_process14.execSync)("git --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
     return {
       id: "git",
@@ -25246,7 +25505,7 @@ function checkAnalysisCli() {
 var INSTALL_TIMEOUT_MS = 12e4;
 function run(command, args, opts = {}) {
   return new Promise((resolve5) => {
-    const child = (0, import_node_child_process13.spawn)(command, args, {
+    const child = (0, import_node_child_process14.spawn)(command, args, {
       stdio: opts.inherit ? "inherit" : "pipe",
       timeout: INSTALL_TIMEOUT_MS
     });
@@ -25296,96 +25555,6 @@ async function checkPrereqs(opts = {}) {
 
 // src/lib/telemetry.ts
 var import_promises15 = require("node:fs/promises");
-
-// src/lib/gitignore.ts
-var import_node_child_process14 = require("node:child_process");
-var import_node_fs48 = require("node:fs");
-var VERITY_GITIGNORE_MARKER = "# Verity \u2014 machine-local state.";
-var SETTINGS_LOCAL_IGNORE_ENTRY = ".claude/settings.local.json";
-var VERITY_GITIGNORE_BLOCK = [
-  "# Verity \u2014 machine-local state. Everything in .verity/ is ignored EXCEPT the",
-  "# shared standard and the knowledge graph, which are meant to be committed.",
-  ".verity/*",
-  "!.verity/standard.yaml",
-  "!.verity/memory/",
-  ".verity/memory/log.md",
-  SETTINGS_LOCAL_IGNORE_ENTRY,
-  ""
-].join("\n");
-var BREAKING_ENTRIES = /* @__PURE__ */ new Set([".verity/", ".verity"]);
-function isIgnored3(path) {
-  try {
-    (0, import_node_child_process14.execSync)(`git check-ignore -q -- "${path}"`, { stdio: "pipe" });
-    return true;
-  } catch (err) {
-    return err.status === 1 ? false : null;
-  }
-}
-function semanticsHold() {
-  const snapshot = isIgnored3(".verity/.snapshot/__probe__");
-  const standard = isIgnored3(".verity/standard.yaml");
-  const node = isIgnored3(".verity/memory/domain/__probe__.md");
-  const futureState = isIgnored3(".verity/.__probe-future-state__");
-  if (snapshot === null || standard === null || node === null || futureState === null) return null;
-  return snapshot === true && futureState === true && standard === false && node === false;
-}
-function ensureVerityGitignore() {
-  let content = "";
-  try {
-    content = (0, import_node_fs48.readFileSync)(".gitignore", "utf-8");
-  } catch {
-  }
-  const hasMarker = content.includes(VERITY_GITIGNORE_MARKER);
-  const lines = content.split("\n");
-  const breakingCount = lines.filter((l) => BREAKING_ENTRIES.has(l.trim())).length;
-  const needsRepair = breakingCount > 0;
-  const verified = (result) => semanticsHold() === false ? "conflict" : result;
-  if (hasMarker && !needsRepair) return verified("covered");
-  if (!hasMarker && !needsRepair) {
-    if (semanticsHold() === true) return "covered";
-  }
-  try {
-    let next = content;
-    if (needsRepair) {
-      next = lines.map((l) => BREAKING_ENTRIES.has(l.trim()) ? ".verity/*" : l).join("\n");
-    }
-    if (!hasMarker) {
-      const sep3 = next === "" ? "" : next.endsWith("\n") ? "\n" : "\n\n";
-      next = next + sep3 + VERITY_GITIGNORE_BLOCK;
-    }
-    (0, import_node_fs48.writeFileSync)(".gitignore", next);
-    return verified(needsRepair ? "repaired" : "added");
-  } catch {
-    return "failed";
-  }
-}
-function committedVerityState() {
-  let out = "";
-  try {
-    out = (0, import_node_child_process14.execSync)("git ls-files -z -- .verity", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-  } catch {
-    return [];
-  }
-  return out.split("\0").filter(Boolean).filter((p) => p !== ".verity/standard.yaml" && !(p.startsWith(".verity/memory/") && p !== ".verity/memory/log.md"));
-}
-function untrackVerityState() {
-  const tracked = committedVerityState();
-  if (tracked.length === 0) return "none";
-  try {
-    (0, import_node_child_process14.execSync)("git rm -r --cached --quiet -- .verity", { stdio: "pipe" });
-    for (const keep of [".verity/standard.yaml", ".verity/memory"]) {
-      try {
-        (0, import_node_child_process14.execSync)(`git add -- "${keep}"`, { stdio: "pipe" });
-      } catch {
-      }
-    }
-    return "untracked";
-  } catch {
-    return "failed";
-  }
-}
-
-// src/lib/telemetry.ts
 var SETTINGS_LOCAL_FILE2 = ".claude/settings.local.json";
 var GITIGNORE_FILE = ".gitignore";
 var GITIGNORE_ENTRY = SETTINGS_LOCAL_IGNORE_ENTRY;
@@ -25481,11 +25650,11 @@ async function buildReport() {
   const wiring = await resolveHookWiring();
   const hooks = wiring.status;
   const telemetry = await checkTelemetry();
-  const hasConfig = (0, import_node_fs49.existsSync)(projectPath(CODACY_CONFIG_FILE));
+  const hasConfig = (0, import_node_fs50.existsSync)(projectPath(CODACY_CONFIG_FILE));
   const artifacts = {
-    standard: (0, import_node_fs49.existsSync)(projectPath(STANDARD_FILE)),
+    standard: (0, import_node_fs50.existsSync)(projectPath(STANDARD_FILE)),
     analysisConfig: hasConfig,
-    verityMd: (0, import_node_fs49.existsSync)(projectPath(VERITY_MD_FILE)),
+    verityMd: (0, import_node_fs50.existsSync)(projectPath(VERITY_MD_FILE)),
     analysisConfigIds: hasConfig ? validatePatternIds().status : "absent"
   };
   const next = [];
@@ -25526,6 +25695,12 @@ async function buildReport() {
   if (state?.telemetry === "deferred") {
     next.push('Telemetry was requested but needs a token \u2014 run "verity login", then "verity telemetry install".');
   }
+  const memory = { posture: memoryPosture(), trackedFiles: committedMemoryFiles().length };
+  if (memory.trackedFiles > 0 && !memoryOptOut()) {
+    next.push(
+      `${memory.trackedFiles} knowledge-graph file(s) under .verity/memory/ are tracked in git, so Verity's generated notes appear in every diff and pull request. Run "verity memory untrack" to stop that (the files stay on disk), or "verity memory track" if this project commits them on purpose.`
+    );
+  }
   const conflict = marketplaceConflict();
   if (conflict) {
     next.push(
@@ -25558,11 +25733,16 @@ async function buildReport() {
     },
     telemetry: { enabled: telemetry.enabled, endpoint: telemetry.endpoint },
     artifacts,
+    memory,
     next
   };
 }
 function registerDoctorCommand(program2) {
   program2.command("doctor").description("Report prerequisites, setup phase, hooks, and what is still missing").option("--json", "Output the full report as JSON (what /verity-setup reads)").action(async (opts) => {
+    try {
+      process.chdir(repoRoot());
+    } catch {
+    }
     const report = await buildReport();
     if (opts.json) {
       printJson(report);
@@ -25590,6 +25770,9 @@ function registerDoctorCommand(program2) {
     const idNote = idState === "valid" ? "\u2713" : idState === "invalid" ? "\u26A0 ids do not resolve" : idState === "unchecked" ? "\u2713 (ids unverified \u2014 no adapter)" : "";
     printInfo(`  .codacy/codacy.config.json: ${report.artifacts.analysisConfig ? idNote : "missing"}`);
     printInfo(`  VERITY.md: ${report.artifacts.verityMd ? "\u2713" : "missing"}`);
+    printInfo(
+      `  .verity/memory/: ${report.memory.trackedFiles > 0 ? `${report.memory.trackedFiles} file(s) tracked in git \u2014 they appear in every diff` : report.memory.posture === "ignored" ? "machine-local \u2713" : "not tracked"}`
+    );
     if (report.next.length > 0) {
       console.log("");
       printWarn("Next:");
@@ -25602,7 +25785,7 @@ function registerDoctorCommand(program2) {
 }
 
 // src/commands/migrate.ts
-var import_node_fs50 = require("node:fs");
+var import_node_fs51 = require("node:fs");
 var import_node_path34 = require("node:path");
 var import_node_child_process15 = require("node:child_process");
 var LEGACY_NPM_PACKAGE = "@codacy/gate-cli";
@@ -25642,10 +25825,10 @@ async function runMigration(opts = {}) {
 function migrateProjectDir(root, actions) {
   const gateDir = (0, import_node_path34.join)(root, ".gate");
   const verityDir = (0, import_node_path34.join)(root, ".verity");
-  if ((0, import_node_fs50.existsSync)(gateDir) && !(0, import_node_fs50.existsSync)(verityDir)) {
+  if ((0, import_node_fs51.existsSync)(gateDir) && !(0, import_node_fs51.existsSync)(verityDir)) {
     return migrateProjectDirRename(root, gateDir, verityDir, actions);
   }
-  if ((0, import_node_fs50.existsSync)(gateDir) && (0, import_node_fs50.existsSync)(verityDir)) {
+  if ((0, import_node_fs51.existsSync)(gateDir) && (0, import_node_fs51.existsSync)(verityDir)) {
     return migrateProjectDirCarry(gateDir, verityDir, actions);
   }
   return false;
@@ -25666,13 +25849,13 @@ function migrateProjectDirRename(root, gateDir, verityDir, actions) {
     }
   }
   if (moved) {
-    if ((0, import_node_fs50.existsSync)(gateDir)) {
+    if ((0, import_node_fs51.existsSync)(gateDir)) {
       const carried = carryLegacyContents(gateDir, verityDir);
       if (carried > 0) {
         actions.push(`Carried ${carried} untracked legacy file(s) from .gate/ into .verity/`);
       }
       try {
-        (0, import_node_fs50.rmSync)(gateDir, { recursive: true, force: true });
+        (0, import_node_fs51.rmSync)(gateDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -25688,7 +25871,7 @@ function migrateProjectDirCarry(gateDir, verityDir, actions) {
     actions.push(`Carried ${carried} legacy file(s) from .gate/ into .verity/`);
   }
   try {
-    (0, import_node_fs50.rmSync)(gateDir, { recursive: true, force: true });
+    (0, import_node_fs51.rmSync)(gateDir, { recursive: true, force: true });
   } catch {
   }
   return carried > 0;
@@ -25697,9 +25880,9 @@ function migrateGlobalCredentials(home, actions) {
   if (!home) return;
   const gateCreds = (0, import_node_path34.join)(home, ".gate", "credentials");
   const verityCreds = (0, import_node_path34.join)(home, ".verity", "credentials");
-  if (!(0, import_node_fs50.existsSync)(gateCreds)) return;
-  if (!(0, import_node_fs50.existsSync)(verityCreds)) {
-    (0, import_node_fs50.mkdirSync)((0, import_node_path34.join)(home, ".verity"), { recursive: true });
+  if (!(0, import_node_fs51.existsSync)(gateCreds)) return;
+  if (!(0, import_node_fs51.existsSync)(verityCreds)) {
+    (0, import_node_fs51.mkdirSync)((0, import_node_path34.join)(home, ".verity"), { recursive: true });
     moveFile(gateCreds, verityCreds);
     actions.push("Moved ~/.gate/credentials \u2192 ~/.verity/credentials");
     return;
@@ -25722,7 +25905,7 @@ async function migrateLegacyHooks(root, actions) {
 }
 async function migrateClaudeMd(root, actions) {
   const claudeMd = (0, import_node_path34.join)(root, "CLAUDE.md");
-  const hadLegacyBlock = (0, import_node_fs50.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd));
+  const hadLegacyBlock = (0, import_node_fs51.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd));
   if (!hadLegacyBlock) return;
   try {
     await ensureClaudeMdPointer(root);
@@ -25734,7 +25917,7 @@ async function migrateClaudeMd(root, actions) {
 function migrateStandardFile(root, actions) {
   const gateMd = (0, import_node_path34.join)(root, "GATE.md");
   const verityMd = (0, import_node_path34.join)(root, "VERITY.md");
-  if (!(0, import_node_fs50.existsSync)(gateMd) || (0, import_node_fs50.existsSync)(verityMd)) return;
+  if (!(0, import_node_fs51.existsSync)(gateMd) || (0, import_node_fs51.existsSync)(verityMd)) return;
   let moved = false;
   if (isGitRepo(root) && isGitTracked(root, "GATE.md")) {
     try {
@@ -25746,12 +25929,12 @@ function migrateStandardFile(root, actions) {
   if (!moved) moveFile(gateMd, verityMd);
   const content = readFileSyncSafe(verityMd);
   const refreshed = content.split("GATE.md").join("VERITY.md");
-  if (refreshed !== content) (0, import_node_fs50.writeFileSync)(verityMd, refreshed);
+  if (refreshed !== content) (0, import_node_fs51.writeFileSync)(verityMd, refreshed);
   actions.push("Renamed GATE.md \u2192 VERITY.md");
 }
 async function migrateTelemetryHeaders(root, actions) {
   const file = (0, import_node_path34.join)(root, ".claude", "settings.local.json");
-  if (!(0, import_node_fs50.existsSync)(file)) return;
+  if (!(0, import_node_fs51.existsSync)(file)) return;
   let settings;
   try {
     settings = JSON.parse(readFileSyncSafe(file) || "{}");
@@ -25799,14 +25982,14 @@ function mergeGlobalCredentials(gateCreds, verityCreds) {
   }
   if (toAppend.length > 0) {
     const sep3 = verityContent.endsWith("\n") || verityContent === "" ? "" : "\n";
-    (0, import_node_fs50.writeFileSync)(verityCreds, verityContent + sep3 + toAppend.join("\n") + "\n");
+    (0, import_node_fs51.writeFileSync)(verityCreds, verityContent + sep3 + toAppend.join("\n") + "\n");
   }
-  (0, import_node_fs50.rmSync)(gateCreds, { force: true });
+  (0, import_node_fs51.rmSync)(gateCreds, { force: true });
   return toAppend.length;
 }
 function readFileSyncSafe(path) {
   try {
-    return (0, import_node_fs50.readFileSync)(path, "utf-8");
+    return (0, import_node_fs51.readFileSync)(path, "utf-8");
   } catch {
     return "";
   }
@@ -25821,35 +26004,35 @@ function hasStagedChanges(root) {
 }
 function moveDir(from, to) {
   try {
-    (0, import_node_fs50.renameSync)(from, to);
+    (0, import_node_fs51.renameSync)(from, to);
   } catch (err) {
     if (err.code !== "EXDEV") throw err;
-    (0, import_node_fs50.cpSync)(from, to, { recursive: true });
-    (0, import_node_fs50.rmSync)(from, { recursive: true, force: true });
+    (0, import_node_fs51.cpSync)(from, to, { recursive: true });
+    (0, import_node_fs51.rmSync)(from, { recursive: true, force: true });
   }
 }
 function moveFile(from, to) {
   try {
-    (0, import_node_fs50.renameSync)(from, to);
+    (0, import_node_fs51.renameSync)(from, to);
   } catch (err) {
     if (err.code !== "EXDEV") throw err;
-    (0, import_node_fs50.cpSync)(from, to);
-    (0, import_node_fs50.rmSync)(from, { force: true });
+    (0, import_node_fs51.cpSync)(from, to);
+    (0, import_node_fs51.rmSync)(from, { force: true });
   }
 }
 function carryLegacyContents(gateDir, verityDir) {
   let copied = 0;
   const walk2 = (relDir) => {
     const srcDir = (0, import_node_path34.join)(gateDir, relDir);
-    for (const entry of (0, import_node_fs50.readdirSync)(srcDir)) {
+    for (const entry of (0, import_node_fs51.readdirSync)(srcDir)) {
       const rel = relDir ? (0, import_node_path34.join)(relDir, entry) : entry;
       const src = (0, import_node_path34.join)(gateDir, rel);
       const dest = (0, import_node_path34.join)(verityDir, rel);
-      if ((0, import_node_fs50.statSync)(src).isDirectory()) {
+      if ((0, import_node_fs51.statSync)(src).isDirectory()) {
         walk2(rel);
-      } else if (!(0, import_node_fs50.existsSync)(dest)) {
-        (0, import_node_fs50.mkdirSync)((0, import_node_path34.dirname)(dest), { recursive: true });
-        (0, import_node_fs50.cpSync)(src, dest);
+      } else if (!(0, import_node_fs51.existsSync)(dest)) {
+        (0, import_node_fs51.mkdirSync)((0, import_node_path34.dirname)(dest), { recursive: true });
+        (0, import_node_fs51.cpSync)(src, dest);
         copied++;
       }
     }
@@ -25860,20 +26043,20 @@ function carryLegacyContents(gateDir, verityDir) {
 async function needsMigration(root = repoRoot()) {
   const gateDir = (0, import_node_path34.join)(root, ".gate");
   const verityDir = (0, import_node_path34.join)(root, ".verity");
-  if ((0, import_node_fs50.existsSync)(gateDir) && !(0, import_node_fs50.existsSync)(verityDir)) return true;
-  if ((0, import_node_fs50.existsSync)(gateDir) && (0, import_node_fs50.existsSync)(verityDir)) {
-    if ((0, import_node_fs50.existsSync)((0, import_node_path34.join)(gateDir, "credentials")) && !(0, import_node_fs50.existsSync)((0, import_node_path34.join)(verityDir, "credentials"))) {
+  if ((0, import_node_fs51.existsSync)(gateDir) && !(0, import_node_fs51.existsSync)(verityDir)) return true;
+  if ((0, import_node_fs51.existsSync)(gateDir) && (0, import_node_fs51.existsSync)(verityDir)) {
+    if ((0, import_node_fs51.existsSync)((0, import_node_path34.join)(gateDir, "credentials")) && !(0, import_node_fs51.existsSync)((0, import_node_path34.join)(verityDir, "credentials"))) {
       return true;
     }
-    if ((0, import_node_fs50.existsSync)((0, import_node_path34.join)(gateDir, "memory")) && !(0, import_node_fs50.existsSync)((0, import_node_path34.join)(verityDir, "memory"))) {
+    if ((0, import_node_fs51.existsSync)((0, import_node_path34.join)(gateDir, "memory")) && !(0, import_node_fs51.existsSync)((0, import_node_path34.join)(verityDir, "memory"))) {
       return true;
     }
   }
   const claudeMd = (0, import_node_path34.join)(root, "CLAUDE.md");
-  if ((0, import_node_fs50.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd))) {
+  if ((0, import_node_fs51.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd))) {
     return true;
   }
-  if ((0, import_node_fs50.existsSync)((0, import_node_path34.join)(root, "GATE.md")) && !(0, import_node_fs50.existsSync)((0, import_node_path34.join)(root, "VERITY.md"))) {
+  if ((0, import_node_fs51.existsSync)((0, import_node_path34.join)(root, "GATE.md")) && !(0, import_node_fs51.existsSync)((0, import_node_path34.join)(root, "VERITY.md"))) {
     return true;
   }
   if (await hasLegacyHooksAt(root)) return true;
@@ -26154,7 +26337,7 @@ async function promptMultiSelect(question, choices, fallback) {
 }
 
 // src/lib/remote-config.ts
-var import_node_fs51 = require("node:fs");
+var import_node_fs52 = require("node:fs");
 var import_promises16 = require("node:fs/promises");
 var import_node_path35 = require("node:path");
 var import_yaml5 = __toESM(require_dist());
@@ -26201,7 +26384,7 @@ async function adoptRemoteSetup(found, opts) {
   written.push(STANDARD_FILE);
   if (rider !== null) {
     const localIgnore = projectPath(VERITYIGNORE_FILE);
-    if (!(0, import_node_fs51.existsSync)(localIgnore)) {
+    if (!(0, import_node_fs52.existsSync)(localIgnore)) {
       await writeOut(VERITYIGNORE_FILE, rider);
       written.push(VERITYIGNORE_FILE);
     } else {
@@ -26359,7 +26542,7 @@ function resolveDataDir2() {
     // local dev: running from repo root
   ];
   for (const candidate of candidates2) {
-    if ((0, import_node_fs52.existsSync)((0, import_node_path36.join)(candidate, "skills"))) {
+    if ((0, import_node_fs53.existsSync)((0, import_node_path36.join)(candidate, "skills"))) {
       return candidate;
     }
   }
@@ -26375,7 +26558,7 @@ async function skillIsCurrent(src, dest) {
   const list2 = (dir) => {
     const out = [];
     const walk2 = (d, prefix) => {
-      for (const e of (0, import_node_fs52.readdirSync)(d, { withFileTypes: true })) {
+      for (const e of (0, import_node_fs53.readdirSync)(d, { withFileTypes: true })) {
         const rel = prefix ? `${prefix}/${e.name}` : e.name;
         if (e.isDirectory()) walk2((0, import_node_path36.join)(d, e.name), rel);
         else if (e.isFile()) out.push(rel);
@@ -26570,7 +26753,7 @@ async function synthesizeLocally(opts) {
 async function healStaleAnalysisConfig(globals) {
   const configPath = projectPath(CODACY_CONFIG_FILE);
   const standardPath = projectPath(STANDARD_FILE);
-  if (!(0, import_node_fs52.existsSync)(configPath) || !(0, import_node_fs52.existsSync)(standardPath)) return;
+  if (!(0, import_node_fs53.existsSync)(configPath) || !(0, import_node_fs53.existsSync)(standardPath)) return;
   const validation = validatePatternIds();
   if (validation.status !== "invalid") return;
   printWarn("  Your analysis config names pattern ids that no longer resolve \u2014 those tools were");
@@ -26673,11 +26856,11 @@ async function installSkills(force, step) {
   for (const skill of SKILLS) {
     const src = (0, import_node_path36.join)(skillsSource, skill);
     const dest = (0, import_node_path36.join)(skillsDest, skill);
-    if (!(0, import_node_fs52.existsSync)(src)) {
+    if (!(0, import_node_fs53.existsSync)(src)) {
       printWarn(`  Skill data not found: ${skill}`);
       continue;
     }
-    if ((0, import_node_fs52.existsSync)(dest) && !force && await skillIsCurrent(src, dest)) {
+    if ((0, import_node_fs53.existsSync)(dest) && !force && await skillIsCurrent(src, dest)) {
       skillsInstalled++;
       continue;
     }
@@ -26751,12 +26934,31 @@ async function scaffoldProject(step, defaultsOnly) {
     printWarn("  .gitignore: the Verity block is in place but git still ignores .verity/standard.yaml");
     printWarn("    Something outside this file covers it \u2014 a global (~/.gitignore) or nested");
     printWarn("    .gitignore, or a pattern we do not recognise. Check: git check-ignore -v .verity/standard.yaml");
-    printWarn("    Until it is fixed, the Standard and the knowledge graph cannot be committed.");
+    printWarn("    Until it is fixed, the Standard cannot be committed.");
   } else if (ignoreResult === "repaired") {
     printInfo("  .gitignore: rewrote `.verity/` to `.verity/*` so the standard stays committable \u2713");
+  } else if (ignoreResult === "memory-fenced") {
+    printInfo("  .gitignore: the knowledge graph is machine-local now \u2014 it stays out of your diffs \u2713");
+  } else if (ignoreResult === "memory-tracked") {
+    printWarn("  .gitignore: this project commits its knowledge graph.");
   } else {
     printInfo(`  .gitignore: Verity block ${ignoreResult === "added" ? "added" : "already covered"} \u2713`);
   }
+  const trackedMemory = memoryOptOut() ? [] : committedMemoryFiles();
+  if (trackedMemory.length > 0) {
+    printWarn(`  ${trackedMemory.length} knowledge-graph file(s) are tracked, so they show up in every diff.`);
+    const fence = defaultsOnly ? false : await promptYes("  Stop tracking them (files stay on disk)? [Y/n] ", { nonInteractive: false });
+    if (fence) {
+      const result = fenceMemory();
+      if (!result.ok) printWarn('  Could not untrack \u2014 run "verity memory untrack" when you can');
+      else printInfo(`  Untracked ${result.untracked} file(s) (staged) and ignored \u2014 commit to finish \u2713`);
+    } else if (defaultsOnly) {
+      printWarn("  Left tracked (--yes did not ask). Convert later with: verity memory untrack");
+    } else {
+      printWarn('  Left tracked. Stop later with "verity memory untrack",');
+      printWarn('    or record it as deliberate with "verity memory track".');
+    }
+  }
   const tracked = committedVerityState();
   if (tracked.length > 0) {
     printWarn(`  ${tracked.length} Verity state file(s) are tracked in git (e.g. ${tracked[0]}).`);
@@ -26766,7 +26968,7 @@ async function scaffoldProject(step, defaultsOnly) {
       if (result === "untracked") printInfo("  Untracked (staged) \u2014 commit to finish \u2713");
       else if (result === "failed") printWarn('  Could not untrack \u2014 run "git rm -r --cached .verity" manually');
     } else {
-      printWarn("  Left tracked. Fix with: git rm -r --cached .verity && git add .verity/standard.yaml .verity/memory");
+      printWarn("  Left tracked. Fix with: git rm -r --cached .verity && git add .verity/standard.yaml");
     }
   }
   try {
@@ -26797,7 +26999,7 @@ function registerInitCommand(program2) {
     const staleMarker = clearStalePluginMarker();
     const pluginMode = opts.plugin === false ? false : opts.pluginMode ?? pluginActiveHere();
     const projectMarkers = [".git", "package.json", "pyproject.toml", "go.mod", "Cargo.toml", "Gemfile", "pom.xml", "build.gradle"];
-    const isProject = projectMarkers.some((m) => (0, import_node_fs52.existsSync)(m));
+    const isProject = projectMarkers.some((m) => (0, import_node_fs53.existsSync)(m));
     if (!isProject) {
       printError("No project detected in the current directory.");
       printInfo('Run "verity init" from your project root.');
@@ -26956,7 +27158,7 @@ function registerInitCommand(program2) {
     }
     step("Your project's Standard");
     let haveStandard = false;
-    if ((0, import_node_fs52.existsSync)(projectPath(STANDARD_FILE))) {
+    if ((0, import_node_fs53.existsSync)(projectPath(STANDARD_FILE))) {
       printInfo("  This project already has .verity/standard.yaml \u2014 keeping it.");
       haveStandard = true;
     } else {
@@ -26986,7 +27188,7 @@ function registerInitCommand(program2) {
         ...telemetryChoice ? { telemetry: telemetryChoice } : {},
         init: {
           completed_at: (/* @__PURE__ */ new Date()).toISOString(),
-          cli_version: true ? "0.32.5-experimental.4d91ca0" : "dev"
+          cli_version: true ? "0.32.6" : "dev"
         }
       });
     } catch (err) {
@@ -27002,7 +27204,7 @@ function registerInitCommand(program2) {
       console.log("                                   learn, memory, insights, reflect)");
       console.log("    .claude/settings.json          hooks, reconciled to your chosen moments");
     }
-    console.log("    .verity/memory/                knowledge base (commit to git)");
+    console.log("    .verity/memory/                knowledge base (machine-local, not committed)");
     console.log("    .verity/standard.yaml          the Standard the gate enforces");
     console.log("    .codacy/codacy.config.json     static-analysis patterns (validated)");
     console.log("    VERITY.md                      project quality overview");
@@ -27036,7 +27238,7 @@ function registerInitCommand(program2) {
 }
 
 // src/commands/uninstall.ts
-var import_node_fs53 = require("node:fs");
+var import_node_fs54 = require("node:fs");
 var import_node_path37 = require("node:path");
 function registerUninstallCommand(program2) {
   program2.command("uninstall").description("Remove Verity from this project (skills, hooks, .verity/, VERITY.md)").option("--dry-run", "Show what would be removed without doing it").option("--purge-global", "Also remove ~/.verity/ (deletes saved tokens \u2014 reconnect requires re-registration)").option("--keep-verity-md", "Keep the project root VERITY.md file").action(async (opts) => {
@@ -27047,10 +27249,10 @@ function registerUninstallCommand(program2) {
     const skillsRoot = projectPath(".claude/skills");
     for (const name of PROJECT_SKILL_NAMES) {
       const dir = (0, import_node_path37.join)(skillsRoot, name);
-      if ((0, import_node_fs53.existsSync)(dir)) {
+      if ((0, import_node_fs54.existsSync)(dir)) {
         actions.push({
           label: `Remove .claude/skills/${name}/`,
-          apply: () => (0, import_node_fs53.rmSync)(dir, { recursive: true, force: true })
+          apply: () => (0, import_node_fs54.rmSync)(dir, { recursive: true, force: true })
         });
       }
     }
@@ -27064,24 +27266,24 @@ function registerUninstallCommand(program2) {
       });
     }
     const verityDir = projectPath(VERITY_DIR);
-    if ((0, import_node_fs53.existsSync)(verityDir)) {
+    if ((0, import_node_fs54.existsSync)(verityDir)) {
       actions.push({
         label: `Remove ${VERITY_DIR}/`,
-        apply: () => (0, import_node_fs53.rmSync)(verityDir, { recursive: true, force: true })
+        apply: () => (0, import_node_fs54.rmSync)(verityDir, { recursive: true, force: true })
       });
     }
     if (!keepVerityMd) {
       const verityMd = projectPath(VERITY_MD_FILE);
-      if ((0, import_node_fs53.existsSync)(verityMd)) {
+      if ((0, import_node_fs54.existsSync)(verityMd)) {
         actions.push({
           label: `Remove ${VERITY_MD_FILE}`,
-          apply: () => (0, import_node_fs53.rmSync)(verityMd, { force: true })
+          apply: () => (0, import_node_fs54.rmSync)(verityMd, { force: true })
         });
       }
     }
     const cleanupEmptyDir = (path) => {
-      if ((0, import_node_fs53.existsSync)(path) && (0, import_node_fs53.statSync)(path).isDirectory() && (0, import_node_fs53.readdirSync)(path).length === 0) {
-        (0, import_node_fs53.rmdirSync)(path);
+      if ((0, import_node_fs54.existsSync)(path) && (0, import_node_fs54.statSync)(path).isDirectory() && (0, import_node_fs54.readdirSync)(path).length === 0) {
+        (0, import_node_fs54.rmdirSync)(path);
       }
     };
     actions.push({
@@ -27093,10 +27295,10 @@ function registerUninstallCommand(program2) {
     });
     const home = process.env.HOME ?? "";
     const globalVerityDir = (0, import_node_path37.join)(home, ".verity");
-    if (purgeGlobal && (0, import_node_fs53.existsSync)(globalVerityDir)) {
+    if (purgeGlobal && (0, import_node_fs54.existsSync)(globalVerityDir)) {
       actions.push({
         label: `Remove ~/.verity/ (global credentials \u2014 reconnect requires re-registration)`,
-        apply: () => (0, import_node_fs53.rmSync)(globalVerityDir, { recursive: true, force: true })
+        apply: () => (0, import_node_fs54.rmSync)(globalVerityDir, { recursive: true, force: true })
       });
     }
     if (actions.length === 0) {
@@ -27290,7 +27492,7 @@ function registerTaskCommands(program2) {
 }
 
 // src/commands/reset.ts
-var import_node_fs54 = require("node:fs");
+var import_node_fs55 = require("node:fs");
 var import_node_path38 = require("node:path");
 function registerResetCommand(program2) {
   program2.command("reset").description("Close the current task and clear transient state").option("--keep-task", "Only purge caches; leave the current task open").option("--all", "Also purge diagnostic logs (.verity/.logs/)").action(async (opts) => {
@@ -27328,11 +27530,11 @@ function registerResetCommand(program2) {
     }
     const cacheDir = projectPath(CACHE_DIR);
     let purged = 0;
-    if ((0, import_node_fs54.existsSync)(cacheDir)) {
-      for (const entry of (0, import_node_fs54.readdirSync)(cacheDir)) {
+    if ((0, import_node_fs55.existsSync)(cacheDir)) {
+      for (const entry of (0, import_node_fs55.readdirSync)(cacheDir)) {
         if (entry.startsWith("pending-")) {
           try {
-            (0, import_node_fs54.unlinkSync)((0, import_node_path38.join)(cacheDir, entry));
+            (0, import_node_fs55.unlinkSync)((0, import_node_path38.join)(cacheDir, entry));
             purged++;
           } catch {
           }
@@ -27347,19 +27549,19 @@ function registerResetCommand(program2) {
       projectPath(`${VERITY_DIR}/.last-analysis`)
     ];
     for (const file of filesToClear) {
-      if ((0, import_node_fs54.existsSync)(file)) {
+      if ((0, import_node_fs55.existsSync)(file)) {
         try {
-          (0, import_node_fs54.writeFileSync)(file, "");
+          (0, import_node_fs55.writeFileSync)(file, "");
         } catch {
         }
       }
     }
     if (opts.all) {
       const logsDir = projectPath(`${VERITY_DIR}/.logs`);
-      if ((0, import_node_fs54.existsSync)(logsDir)) {
-        for (const entry of (0, import_node_fs54.readdirSync)(logsDir)) {
+      if ((0, import_node_fs55.existsSync)(logsDir)) {
+        for (const entry of (0, import_node_fs55.readdirSync)(logsDir)) {
           try {
-            (0, import_node_fs54.unlinkSync)((0, import_node_path38.join)(logsDir, entry));
+            (0, import_node_fs55.unlinkSync)((0, import_node_path38.join)(logsDir, entry));
           } catch {
           }
         }
@@ -27550,12 +27752,64 @@ function registerMemoryCommand(program2) {
     }
     console.log("");
     if (result.failed === 0) {
-      printInfo(`Seeded ${result.created} knowledge node(s) from the Standard. Commit .verity/memory/ to share with your team.`);
+      printInfo(`Seeded ${result.created} knowledge node(s) from the Standard into .verity/memory/.`);
     } else {
       printWarn(`Seeded ${result.created} node(s); ${result.failed} failed. See messages above.`);
     }
     process.exit(result.failed === 0 ? 0 : 1);
   });
+  memory.command("untrack").description("Stop committing .verity/memory/ \u2014 the graph stays on disk and leaves your diffs").action(() => {
+    try {
+      process.chdir(repoRoot());
+    } catch {
+    }
+    const tracked = committedMemoryFiles();
+    if (tracked.length === 0 && memoryPosture() === "ignored") {
+      printInfo("The knowledge graph is already machine-local \u2014 nothing to do.");
+      process.exit(0);
+    }
+    const result = fenceMemory();
+    if (!result.ok) {
+      printError(
+        "Could not fence .verity/memory/. Either .gitignore is not writable, or a rule we do not own still re-includes it. Check: git check-ignore -v .verity/memory/index.md"
+      );
+      process.exit(1);
+    }
+    if (result.untracked > 0) {
+      printInfo(`Removed ${result.untracked} file(s) from the index. They are still on disk \u2014 nothing was deleted.`);
+      printWarn("The deletions are STAGED: commit them so the rest of your team picks this up.");
+      printWarn("  Your teammates will see .verity/memory/ disappear when they pull this commit.");
+      printWarn("  That is expected: the graph is rebuilt from the service on their next analysis.");
+    }
+    printInfo(".verity/memory/ is ignored now. It will not appear in a diff or pull request again.");
+    printInfo('Changed your mind? "verity memory track" puts it back and records that it is deliberate.');
+    process.exit(0);
+  });
+  memory.command("track").description("Commit .verity/memory/ on purpose, and record that choice so nothing offers to change it").action(() => {
+    try {
+      process.chdir(repoRoot());
+    } catch {
+    }
+    const result = keepMemoryTracked();
+    if (result === "failed") {
+      printError("Could not write .gitignore.");
+      process.exit(1);
+    }
+    if (result === "already") {
+      printInfo("Already recorded \u2014 this project commits its knowledge graph on purpose.");
+      process.exit(0);
+    }
+    if (result === "refused") {
+      printError("Recorded the opt-out, but git STILL ignores .verity/memory/.");
+      printWarn('  A bare ".verity/" entry makes every "!" line beneath it unreachable.');
+      printWarn("  Check: git check-ignore -v .verity/memory/index.md");
+      printWarn('  "verity init" rewrites that entry to ".verity/*", which makes the opt-out live.');
+      process.exit(1);
+    }
+    printInfo("Recorded in .gitignore: this project commits its knowledge graph on purpose.");
+    printInfo("Commit that .gitignore change so your team inherits it, then: git add .verity/memory");
+    process.exit(0);
+  });
 }
 
 // src/commands/run.ts
@@ -27667,8 +27921,8 @@ function registerTelemetryCommands(program2) {
 }
 
 // src/cli.ts
-program.name("verity").description("CLI for Verity quality gate service").version("0.32.5-experimental.4d91ca0").option("--token <token>", "Override authentication token").option("--service-url <url>", "Override service URL").option("--verbose", "Log HTTP requests/responses to stderr").hook("preAction", async (_thisCommand, actionCommand) => {
-  installStderrLog(actionCommand.name(), process.argv.slice(2), "0.32.5-experimental.4d91ca0");
+program.name("verity").description("CLI for Verity quality gate service").version("0.32.6").option("--token <token>", "Override authentication token").option("--service-url <url>", "Override service URL").option("--verbose", "Log HTTP requests/responses to stderr").hook("preAction", async (_thisCommand, actionCommand) => {
+  installStderrLog(actionCommand.name(), process.argv.slice(2), "0.32.6");
   setUserNamedServiceUrl(program.opts().serviceUrl);
   try {
     await foldLegacyLocalCredential();