@codacy/verity-cli 0.32.6-experimental.8f2b5f7 → 0.32.6-experimental.df0a578

package/bin/verity.js

@@ -13846,14 +13846,206 @@ async function appendEntry(taskId, entry) {
 }
 
 // src/lib/memory-retrieval.ts
-var import_promises7 = require("node:fs/promises");
+var import_promises8 = require("node:fs/promises");
+var import_node_fs11 = require("node:fs");
+var import_node_path11 = require("node:path");
+
+// src/lib/org-mirror.ts
 var import_node_fs10 = require("node:fs");
+var import_promises7 = require("node:fs/promises");
 var import_node_path10 = require("node:path");
+var ORG_KINDS = ["decision", "security", "gotcha", "pattern", "domain", "integration"];
+var STATE_FILE = ".org-pull-state.json";
+var BODY_MAX = 8192;
+function orgMirrorDir(remote = requestRemote()) {
+  const parsed = parseRemote(remote);
+  if (!parsed) return null;
+  return (0, import_node_path10.join)(verityHome(), "orgs", parsed.host, parsed.owner.toLowerCase(), "memory");
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+}
+function orgNodePath(node) {
+  const kind = ORG_KINDS.includes(node.kind) ? node.kind : "domain";
+  return `${kind}/${slugify(node.title) || "claim"}-${node.tag_id.replace(/-/g, "").slice(0, 8)}.md`;
+}
+function renderOrgNode(node, orgName) {
+  const fm = [
+    "---",
+    `id: ${JSON.stringify(node.tag_id)}`,
+    `node_id: ${JSON.stringify(node.node_id)}`,
+    'scope: "org"',
+    `org: ${JSON.stringify(orgName)}`,
+    `kind: ${JSON.stringify(node.kind)}`,
+    `title: ${JSON.stringify(node.title)}`,
+    `origin: ${JSON.stringify(node.origin)}`,
+    `signal: ${JSON.stringify(node.signal)}`,
+    `tier: ${node.tier === null ? "null" : JSON.stringify(node.tier)}`,
+    `applies_to: ${JSON.stringify(node.applies_to)}`,
+    `source_repo_count: ${JSON.stringify(node.source_repo_count)}`,
+    `promoted_at: ${JSON.stringify(node.promoted_at)}`,
+    'status: "active"',
+    "---"
+  ];
+  return `${fm.join("\n")}
+
+# ${node.title}
+
+${node.body.trim()}
+`;
+}
+function parseOrgNode(content) {
+  const m = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!m) return null;
+  const fm = {};
+  for (const line of m[1].split("\n")) {
+    const kv = line.match(/^([a-z_]+):\s*(.*)$/);
+    if (!kv) continue;
+    try {
+      fm[kv[1]] = JSON.parse(kv[2]);
+    } catch {
+      fm[kv[1]] = kv[2];
+    }
+  }
+  if (fm.scope !== "org" || typeof fm.id !== "string" || typeof fm.title !== "string") return null;
+  if (fm.status && fm.status !== "active") return null;
+  const body = m[2].replace(/^\s*#[^\n]*\n/, "").trim();
+  return {
+    tag_id: fm.id,
+    node_id: typeof fm.node_id === "string" ? fm.node_id : "",
+    kind: typeof fm.kind === "string" ? fm.kind : "domain",
+    title: fm.title,
+    body,
+    origin: typeof fm.origin === "string" ? fm.origin : "",
+    signal: typeof fm.signal === "string" ? fm.signal : "",
+    tier: typeof fm.tier === "number" ? fm.tier : null,
+    applies_to: Array.isArray(fm.applies_to) ? fm.applies_to.filter((v) => typeof v === "string") : [],
+    source_repo_count: typeof fm.source_repo_count === "number" ? fm.source_repo_count : 1,
+    promoted_at: typeof fm.promoted_at === "string" ? fm.promoted_at : ""
+  };
+}
+async function readState(dir) {
+  try {
+    const parsed = JSON.parse(await (0, import_promises7.readFile)((0, import_node_path10.join)(dir, STATE_FILE), "utf-8"));
+    return {
+      version: typeof parsed?.version === "string" ? parsed.version : null,
+      organization: parsed?.organization && typeof parsed.organization.id === "string" ? parsed.organization : null,
+      files: Array.isArray(parsed?.files) ? parsed.files.filter((f) => typeof f === "string") : []
+    };
+  } catch {
+    return { version: null, organization: null, files: [] };
+  }
+}
+async function writeState(dir, state) {
+  await (0, import_promises7.mkdir)(dir, { recursive: true });
+  await (0, import_promises7.writeFile)((0, import_node_path10.join)(dir, STATE_FILE), JSON.stringify({
+    ...state.version ? { version: state.version } : {},
+    organization: state.organization,
+    pulled_at: (/* @__PURE__ */ new Date()).toISOString(),
+    files: state.files
+  }, null, 2) + "\n");
+}
+function renderIndex(orgName, nodes) {
+  const lines = [
+    `# Org Knowledge \u2014 ${orgName}`,
+    "",
+    "*Auto-generated by verity CLI from what this organization's repositories learned. Do not hand-edit; `verity memory pull` overwrites it.*",
+    "",
+    '> These claims hold across the organization\'s repositories, not only this one. Each names where it came from. A claim that is wrong for this repository is demoted with `verity memory demote <id> --reason "\u2026"`, for everyone.',
+    ""
+  ];
+  const byKind = /* @__PURE__ */ new Map();
+  for (const n of nodes) byKind.set(n.kind, [...byKind.get(n.kind) ?? [], n]);
+  for (const kind of ORG_KINDS) {
+    const list2 = byKind.get(kind);
+    if (!list2?.length) continue;
+    lines.push(`## ${kind}/ (${list2.length})`);
+    for (const n of list2) lines.push(`- [[${orgNodePath(n).split("/")[1].replace(/\.md$/, "")}]] \u2014 ${n.title} \xB7 ${n.origin}`);
+    lines.push("");
+  }
+  if (nodes.length === 0) lines.push("No org knowledge yet.", "");
+  return lines.join("\n");
+}
+async function pullOrgKnowledge(opts) {
+  const dir = orgMirrorDir(opts.remote ?? requestRemote());
+  if (!dir) return { ok: true, status: "no_remote", received: 0, dir: null };
+  const state = await readState(dir);
+  const params = new URLSearchParams({ for: "agent" });
+  if (!opts.force && state.version) params.set("if_version", state.version);
+  const res = await apiRequest({
+    method: "GET",
+    path: `/memory/org?${params.toString()}`,
+    serviceUrl: opts.serviceUrl,
+    token: opts.token,
+    verbose: opts.verbose,
+    timeout: opts.timeoutMs ?? 3e4,
+    cmd: "memory-org-pull"
+  });
+  if (!res.ok) return { ok: false, error: res.error, category: res.category };
+  const page = res.data;
+  if (page.unchanged) return { ok: true, status: "unchanged", received: 0, dir };
+  const org = page.organization;
+  const nodes = org ? (page.nodes ?? []).flatMap((n) => typeof n.tag_id === "string" && typeof n.title === "string" && typeof n.body === "string" ? [{
+    tag_id: n.tag_id,
+    node_id: typeof n.node_id === "string" ? n.node_id : "",
+    kind: typeof n.kind === "string" ? n.kind : "domain",
+    title: n.title,
+    body: n.body.slice(0, BODY_MAX),
+    origin: typeof n.origin === "string" ? n.origin : "",
+    signal: typeof n.signal === "string" ? n.signal : "",
+    tier: typeof n.tier === "number" ? n.tier : null,
+    applies_to: Array.isArray(n.applies_to) ? n.applies_to.filter((v) => typeof v === "string") : [],
+    source_repo_count: typeof n.source_repo_count === "number" ? n.source_repo_count : 1,
+    promoted_at: typeof n.promoted_at === "string" ? n.promoted_at : ""
+  }] : []) : [];
+  const written = /* @__PURE__ */ new Set();
+  await (0, import_promises7.mkdir)(dir, { recursive: true });
+  for (const n of nodes) {
+    const rel = orgNodePath(n);
+    if (written.has(rel)) continue;
+    await (0, import_promises7.mkdir)((0, import_node_path10.join)(dir, rel.split("/")[0]), { recursive: true });
+    await (0, import_promises7.writeFile)((0, import_node_path10.join)(dir, rel), renderOrgNode(n, org?.name ?? ""));
+    written.add(rel);
+  }
+  for (const rel of state.files) {
+    if (!written.has(rel)) await (0, import_promises7.rm)((0, import_node_path10.join)(dir, rel), { force: true });
+  }
+  await (0, import_promises7.writeFile)((0, import_node_path10.join)(dir, "index.md"), renderIndex(org?.name ?? "no organization", nodes));
+  await writeState(dir, { version: org ? page.version : null, organization: org, files: [...written].sort() });
+  return { ok: true, status: org ? "pulled" : "none", received: nodes.length, dir };
+}
+async function readOrgMirror(remote = requestRemote()) {
+  const dir = orgMirrorDir(remote);
+  if (!dir || !(0, import_node_fs10.existsSync)(dir)) return [];
+  const out = [];
+  for (const kind of ORG_KINDS) {
+    const kindDir = (0, import_node_path10.join)(dir, kind);
+    if (!(0, import_node_fs10.existsSync)(kindDir)) continue;
+    let files;
+    try {
+      files = await (0, import_promises7.readdir)(kindDir);
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (!file.endsWith(".md")) continue;
+      try {
+        const node = parseOrgNode(await (0, import_promises7.readFile)((0, import_node_path10.join)(kindDir, file), "utf-8"));
+        if (node) out.push(node);
+      } catch {
+      }
+    }
+  }
+  return out;
+}
+
+// src/lib/memory-retrieval.ts
 var memoryDir = () => projectPath(`${VERITY_DIR}/memory`);
 var DOMAINS = ["decisions", "quality", "security", "intent", "gotchas", "patterns", "domain", "integrations"];
 var DEFAULT_BUDGET_TOKENS = 2e3;
 var MAX_BUDGET_TOKENS = 4e3;
 var MIN_SCORE = 0.5;
+var ORG_MIN_SHARED_TERMS = 2;
 function tokenize(text) {
   return new Set(
     text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 2)
@@ -13866,6 +14058,26 @@ function jaccardKeywords(a, b) {
   const union = a.size + b.size - inter;
   return union === 0 ? 0 : inter / union;
 }
+function sharedTerms(a, b) {
+  let n = 0;
+  for (const w of a) if (b.has(w)) n++;
+  return n;
+}
+function orgNodeToLocal(n) {
+  return {
+    path: `org:${n.tag_id}`,
+    nodeId: n.tag_id,
+    kind: n.kind,
+    title: n.title,
+    body: n.body.slice(0, 2e3),
+    fileGlobs: [],
+    confidence: 0.5,
+    citedCount: 0,
+    tokenEstimate: Math.ceil((n.title.length + n.body.length) / 4) + 20,
+    scope: "org",
+    origin: n.origin
+  };
+}
 function globMatch(glob, filePath) {
   if (glob === filePath) return true;
   const suffixMatch = glob.match(/^\*\*\/\*(.+)$/);
@@ -13941,19 +14153,19 @@ function parseFrontmatter(content) {
   return { fm, body: match[2].trim() };
 }
 async function retrieveForInjection(promptText, taskFiles = [], budgetTokens = DEFAULT_BUDGET_TOKENS) {
-  if (!(0, import_node_fs10.existsSync)(memoryDir())) return null;
+  const hasRepoGraph = (0, import_node_fs11.existsSync)(memoryDir());
   const budget = Math.min(budgetTokens, MAX_BUDGET_TOKENS);
   const promptTokens = tokenize(promptText);
   const nodes = [];
-  for (const domain of DOMAINS) {
-    const domainDir = (0, import_node_path10.join)(memoryDir(), domain);
-    if (!(0, import_node_fs10.existsSync)(domainDir)) continue;
+  for (const domain of hasRepoGraph ? DOMAINS : []) {
+    const domainDir = (0, import_node_path11.join)(memoryDir(), domain);
+    if (!(0, import_node_fs11.existsSync)(domainDir)) continue;
     try {
-      const files = await (0, import_promises7.readdir)(domainDir);
+      const files = await (0, import_promises8.readdir)(domainDir);
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
         try {
-          const content = await (0, import_promises7.readFile)((0, import_node_path10.join)(domainDir, file), "utf-8");
+          const content = await (0, import_promises8.readFile)((0, import_node_path11.join)(domainDir, file), "utf-8");
           const { fm, body } = parseFrontmatter(content);
           if (fm.status && fm.status !== "active") continue;
           nodes.push({
@@ -13973,6 +14185,13 @@ async function retrieveForInjection(promptText, taskFiles = [], budgetTokens = D
     } catch {
     }
   }
+  try {
+    for (const claim of await readOrgMirror()) {
+      const local = orgNodeToLocal(claim);
+      if (sharedTerms(tokenize(`${local.title} ${local.body}`), promptTokens) >= ORG_MIN_SHARED_TERMS) nodes.push(local);
+    }
+  } catch {
+  }
   if (nodes.length === 0) return null;
   const scored = nodes.map((n) => ({
     ...n,
@@ -13991,12 +14210,13 @@ async function retrieveForInjection(promptText, taskFiles = [], budgetTokens = D
   const lines = [
     "## Project Knowledge (auto-injected)",
     "",
-    `*${selected.length} node(s) relevant to your current task. See \`.verity/memory/index.md\` for the full knowledge base.*`,
+    `*${selected.length} node(s) relevant to your current task. See \`.verity/memory/index.md\` for the full knowledge base${selected.some((n) => n.scope === "org") ? ", and `~/.verity/orgs/` for what the organization's other repositories learned" : ""}.*`,
     ""
   ];
   for (const node of selected) {
     lines.push(`### ${node.title}`);
-    lines.push(`*${node.kind}* \xB7 confidence ${Math.round(node.confidence * 100)}%`);
+    if (node.scope === "org") lines.push(`*org \xB7 ${node.origin}* \xB7 ${node.kind}`);
+    else lines.push(`*${node.kind}* \xB7 confidence ${Math.round(node.confidence * 100)}%`);
     lines.push("");
     lines.push(node.body.slice(0, 800));
     lines.push("");
@@ -14011,14 +14231,14 @@ async function retrieveForInjection(promptText, taskFiles = [], budgetTokens = D
 }
 
 // src/lib/memory-sync.ts
-var import_promises8 = require("node:fs/promises");
-var import_node_fs13 = require("node:fs");
-var import_node_path12 = require("node:path");
+var import_promises9 = require("node:fs/promises");
+var import_node_fs14 = require("node:fs");
+var import_node_path13 = require("node:path");
 var import_node_crypto3 = require("node:crypto");
 
 // src/lib/gitignore.ts
 var import_node_child_process6 = require("node:child_process");
-var import_node_fs11 = require("node:fs");
+var import_node_fs12 = 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 = [
@@ -14102,7 +14322,7 @@ function fenceMemoryLines(lines) {
 function ensureVerityGitignore() {
   let content = "";
   try {
-    content = (0, import_node_fs11.readFileSync)(".gitignore", "utf-8");
+    content = (0, import_node_fs12.readFileSync)(".gitignore", "utf-8");
   } catch {
   }
   const hasMarker = content.includes(VERITY_GITIGNORE_MARKER);
@@ -14129,7 +14349,7 @@ function ensureVerityGitignore() {
       const sep4 = text === "" ? "" : text.endsWith("\n") ? "\n" : "\n\n";
       text = text + sep4 + VERITY_GITIGNORE_BLOCK;
     }
-    if (text !== content) (0, import_node_fs11.writeFileSync)(".gitignore", text);
+    if (text !== content) (0, import_node_fs12.writeFileSync)(".gitignore", text);
     return verified(
       memoryIsCommitted ? "memory-tracked" : hasSupersededMemory ? "memory-fenced" : needsRepair ? "repaired" : "added"
     );
@@ -14149,7 +14369,7 @@ function untrackMemory() {
 function writeFencedBlock() {
   let content = "";
   try {
-    content = (0, import_node_fs11.readFileSync)(".gitignore", "utf-8");
+    content = (0, import_node_fs12.readFileSync)(".gitignore", "utf-8");
   } catch {
   }
   const hasMarker = content.includes(VERITY_GITIGNORE_MARKER);
@@ -14161,7 +14381,7 @@ function writeFencedBlock() {
     text = text + sep4 + VERITY_GITIGNORE_BLOCK;
   }
   try {
-    (0, import_node_fs11.writeFileSync)(".gitignore", text);
+    (0, import_node_fs12.writeFileSync)(".gitignore", text);
     return true;
   } catch {
     return false;
@@ -14170,14 +14390,14 @@ function writeFencedBlock() {
 function fenceMemory() {
   let original = null;
   try {
-    original = (0, import_node_fs11.readFileSync)(".gitignore", "utf-8");
+    original = (0, import_node_fs12.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);
+      if (original === null) (0, import_node_fs12.rmSync)(".gitignore", { force: true });
+      else (0, import_node_fs12.writeFileSync)(".gitignore", original);
     } catch {
     }
   };
@@ -14195,7 +14415,7 @@ function fenceMemory() {
 }
 function memoryOptOut() {
   try {
-    return (0, import_node_fs11.readFileSync)(".gitignore", "utf-8").includes(MEMORY_OPT_OUT_MARKER);
+    return (0, import_node_fs12.readFileSync)(".gitignore", "utf-8").includes(MEMORY_OPT_OUT_MARKER);
   } catch {
     return false;
   }
@@ -14203,13 +14423,13 @@ function memoryOptOut() {
 function keepMemoryTracked() {
   let content = "";
   try {
-    content = (0, import_node_fs11.readFileSync)(".gitignore", "utf-8");
+    content = (0, import_node_fs12.readFileSync)(".gitignore", "utf-8");
   } catch {
   }
   if (content.includes(MEMORY_OPT_OUT_MARKER)) return "already";
   try {
     const sep4 = content === "" ? "" : content.endsWith("\n") ? "\n" : "\n\n";
-    (0, import_node_fs11.writeFileSync)(".gitignore", content + sep4 + MEMORY_OPT_OUT_STANZA);
+    (0, import_node_fs12.writeFileSync)(".gitignore", content + sep4 + MEMORY_OPT_OUT_STANZA);
   } catch {
     return "failed";
   }
@@ -14244,26 +14464,26 @@ function untrackVerityState() {
 }
 
 // src/lib/safe-path.ts
-var import_node_fs12 = require("node:fs");
-var import_node_path11 = require("node:path");
+var import_node_fs13 = require("node:fs");
+var import_node_path12 = require("node:path");
 function resolveInside(baseDir, candidate) {
   if (typeof candidate !== "string" || candidate.length === 0) return null;
-  if ((0, import_node_path11.isAbsolute)(candidate)) return null;
-  const baseAbs = (0, import_node_path11.resolve)(baseDir);
-  const full = (0, import_node_path11.resolve)(baseAbs, candidate);
-  const baseSep = baseAbs.endsWith(import_node_path11.sep) ? baseAbs : baseAbs + import_node_path11.sep;
+  if ((0, import_node_path12.isAbsolute)(candidate)) return null;
+  const baseAbs = (0, import_node_path12.resolve)(baseDir);
+  const full = (0, import_node_path12.resolve)(baseAbs, candidate);
+  const baseSep = baseAbs.endsWith(import_node_path12.sep) ? baseAbs : baseAbs + import_node_path12.sep;
   if (full !== baseAbs && !full.startsWith(baseSep)) return null;
   try {
-    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;
+    if ((0, import_node_fs13.existsSync)(baseAbs)) {
+      const realBase = (0, import_node_fs13.realpathSync)(baseAbs);
+      const realBaseSep = realBase.endsWith(import_node_path12.sep) ? realBase : realBase + import_node_path12.sep;
       let probe = full;
-      while (!(0, import_node_fs12.existsSync)(probe)) {
-        const parent = (0, import_node_path11.dirname)(probe);
+      while (!(0, import_node_fs13.existsSync)(probe)) {
+        const parent = (0, import_node_path12.dirname)(probe);
         if (parent === probe) break;
         probe = parent;
       }
-      const realProbe = (0, import_node_fs12.realpathSync)(probe);
+      const realProbe = (0, import_node_fs13.realpathSync)(probe);
       if (realProbe !== realBase && !realProbe.startsWith(realBaseSep)) return null;
     }
   } catch {
@@ -14346,36 +14566,36 @@ var memoryDir2 = () => projectPath(`${VERITY_DIR}/memory`);
 var DOMAINS2 = ["decisions", "quality", "security", "intent", "gotchas", "patterns", "domain", "integrations", "_archive"];
 var syncStateFile = () => projectPath(`${VERITY_DIR}/.memory-sync-state.json`);
 async function ensureMemoryDir() {
-  await (0, import_promises8.mkdir)(memoryDir2(), { recursive: true });
+  await (0, import_promises9.mkdir)(memoryDir2(), { recursive: true });
   for (const domain of DOMAINS2) {
-    await (0, import_promises8.mkdir)((0, import_node_path12.join)(memoryDir2(), domain), { recursive: true });
+    await (0, import_promises9.mkdir)((0, import_node_path13.join)(memoryDir2(), domain), { recursive: true });
   }
-  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_fs14.existsSync)((0, import_node_path13.join)(memoryDir2(), "SCHEMA.md"))) {
+    await (0, import_promises9.writeFile)((0, import_node_path13.join)(memoryDir2(), "SCHEMA.md"), SCHEMA_TEMPLATE);
   }
-  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_fs14.existsSync)((0, import_node_path13.join)(memoryDir2(), "index.md"))) {
+    await (0, import_promises9.writeFile)((0, import_node_path13.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_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");
+  if (!(0, import_node_fs14.existsSync)((0, import_node_path13.join)(memoryDir2(), "log.md"))) {
+    await (0, import_promises9.writeFile)((0, import_node_path13.join)(memoryDir2(), "log.md"), "# Memory Log\n\n");
   }
 }
 async function buildManifest() {
-  if (!(0, import_node_fs13.existsSync)(memoryDir2())) {
+  if (!(0, import_node_fs14.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_fs13.existsSync)(domainDir)) continue;
+    const domainDir = (0, import_node_path13.join)(memoryDir2(), domain);
+    if (!(0, import_node_fs14.existsSync)(domainDir)) continue;
     try {
-      const files = await (0, import_promises8.readdir)(domainDir);
+      const files = await (0, import_promises9.readdir)(domainDir);
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
         const filePath = `${domain}/${file}`;
-        const fullPath = (0, import_node_path12.join)(memoryDir2(), filePath);
+        const fullPath = (0, import_node_path13.join)(memoryDir2(), filePath);
         try {
-          const content = await (0, import_promises8.readFile)(fullPath, "utf-8");
+          const content = await (0, import_promises9.readFile)(fullPath, "utf-8");
           const hash = (0, import_node_crypto3.createHash)("sha256").update(content).digest("hex").slice(0, 16);
           nodes.push({ path: filePath, content_hash: `sha256:${hash}` });
         } catch {
@@ -14386,13 +14606,13 @@ async function buildManifest() {
   }
   let indexHash = null;
   try {
-    const indexContent = await (0, import_promises8.readFile)((0, import_node_path12.join)(memoryDir2(), "index.md"), "utf-8");
+    const indexContent = await (0, import_promises9.readFile)((0, import_node_path13.join)(memoryDir2(), "index.md"), "utf-8");
     indexHash = `sha256:${(0, import_node_crypto3.createHash)("sha256").update(indexContent).digest("hex").slice(0, 16)}`;
   } catch {
   }
   let logLength = 0;
   try {
-    const logContent = await (0, import_promises8.readFile)((0, import_node_path12.join)(memoryDir2(), "log.md"), "utf-8");
+    const logContent = await (0, import_promises9.readFile)((0, import_node_path13.join)(memoryDir2(), "log.md"), "utf-8");
     logLength = logContent.split("\n").length;
   } catch {
   }
@@ -14403,15 +14623,15 @@ function hashContent(content) {
 }
 async function readOnDiskNodes() {
   const out = /* @__PURE__ */ new Map();
-  if (!(0, import_node_fs13.existsSync)(memoryDir2())) return out;
+  if (!(0, import_node_fs14.existsSync)(memoryDir2())) return out;
   for (const domain of DOMAINS2) {
-    const domainDir = (0, import_node_path12.join)(memoryDir2(), domain);
-    if (!(0, import_node_fs13.existsSync)(domainDir)) continue;
+    const domainDir = (0, import_node_path13.join)(memoryDir2(), domain);
+    if (!(0, import_node_fs14.existsSync)(domainDir)) continue;
     try {
-      for (const file of await (0, import_promises8.readdir)(domainDir)) {
+      for (const file of await (0, import_promises9.readdir)(domainDir)) {
         if (!file.endsWith(".md")) continue;
         try {
-          out.set(`${domain}/${file}`, hashContent(await (0, import_promises8.readFile)((0, import_node_path12.join)(domainDir, file), "utf-8")));
+          out.set(`${domain}/${file}`, hashContent(await (0, import_promises9.readFile)((0, import_node_path13.join)(domainDir, file), "utf-8")));
         } catch {
         }
       }
@@ -14423,7 +14643,7 @@ async function readOnDiskNodes() {
 async function readSyncBaseline() {
   const out = /* @__PURE__ */ new Map();
   try {
-    const parsed = JSON.parse(await (0, import_promises8.readFile)(syncStateFile(), "utf-8"));
+    const parsed = JSON.parse(await (0, import_promises9.readFile)(syncStateFile(), "utf-8"));
     if (Array.isArray(parsed?.nodes)) {
       for (const n of parsed.nodes) if (n?.path) out.set(n.path, n.hash ?? null);
     } else if (Array.isArray(parsed?.paths)) {
@@ -14439,7 +14659,7 @@ async function recordSyncedNodePaths() {
     const next = JSON.stringify({ schema: 2, nodes }) + "\n";
     let existing = "";
     try {
-      existing = await (0, import_promises8.readFile)(syncStateFile(), "utf-8");
+      existing = await (0, import_promises9.readFile)(syncStateFile(), "utf-8");
     } catch {
     }
     if (existing === next) return;
@@ -14448,10 +14668,10 @@ async function recordSyncedNodePaths() {
   }
 }
 async function writeFileAtomic(path, content) {
-  await (0, import_promises8.mkdir)((0, import_node_path12.dirname)(path), { recursive: true });
+  await (0, import_promises9.mkdir)((0, import_node_path13.dirname)(path), { recursive: true });
   const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
-  await (0, import_promises8.writeFile)(tmp, content);
-  await (0, import_promises8.rename)(tmp, path);
+  await (0, import_promises9.writeFile)(tmp, content);
+  await (0, import_promises9.rename)(tmp, path);
 }
 async function recordSyncBaseline() {
   await recordSyncedNodePaths();
@@ -14462,11 +14682,11 @@ async function computeEditedNodeUploads() {
   const uploads = [];
   for (const [path, prevHash] of prev) {
     if (prevHash == null) continue;
-    const full = (0, import_node_path12.join)(memoryDir2(), path);
-    if (!(0, import_node_fs13.existsSync)(full)) continue;
+    const full = (0, import_node_path13.join)(memoryDir2(), path);
+    if (!(0, import_node_fs14.existsSync)(full)) continue;
     let content;
     try {
-      content = await (0, import_promises8.readFile)(full, "utf-8");
+      content = await (0, import_promises9.readFile)(full, "utf-8");
     } catch {
       continue;
     }
@@ -14507,8 +14727,8 @@ 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_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");
+    const existing = (0, import_node_fs14.existsSync)((0, import_node_path13.join)(memoryDir2(), "log.md")) ? await (0, import_promises9.readFile)((0, import_node_path13.join)(memoryDir2(), "log.md"), "utf-8") : "# Memory Log\n\n";
+    await (0, import_promises9.writeFile)((0, import_node_path13.join)(memoryDir2(), "log.md"), existing + logLines.join("\n") + "\n");
   } catch {
   }
   if (opts.baseline === "written") await mergeSyncBaseline(synced);
@@ -14518,9 +14738,9 @@ async function applyMemoryWrites(writes, opts = {}) {
 async function mergeSyncBaseline(entries) {
   if (entries.size === 0) return;
   try {
-    if ((0, import_node_fs13.existsSync)(syncStateFile())) {
+    if ((0, import_node_fs14.existsSync)(syncStateFile())) {
       try {
-        JSON.parse(await (0, import_promises8.readFile)(syncStateFile(), "utf-8"));
+        JSON.parse(await (0, import_promises9.readFile)(syncStateFile(), "utf-8"));
       } catch {
         return;
       }
@@ -14546,10 +14766,10 @@ async function applyOneWrite(write, treePaths, lastServed) {
       notes.push(`${write.path}: dropped unmatched file_globs [${grounded.dropped.join(", ")}]`);
     }
   }
-  if ((0, import_node_fs13.existsSync)(fullPath)) {
+  if ((0, import_node_fs14.existsSync)(fullPath)) {
     let existing = "";
     try {
-      existing = await (0, import_promises8.readFile)(fullPath, "utf-8");
+      existing = await (0, import_promises9.readFile)(fullPath, "utf-8");
     } catch {
     }
     if (existing === content) return { written: false, syncedHash: hashContent(content), notes };
@@ -14562,8 +14782,8 @@ async function applyOneWrite(write, treePaths, lastServed) {
       notes.push(`${write.path}: updated from server (untouched here since the server delivered it)`);
     }
   }
-  await (0, import_promises8.mkdir)((0, import_node_path12.dirname)(fullPath), { recursive: true });
-  await (0, import_promises8.writeFile)(fullPath, content);
+  await (0, import_promises9.mkdir)((0, import_node_path13.dirname)(fullPath), { recursive: true });
+  await (0, import_promises9.writeFile)(fullPath, content);
   return { written: true, syncedHash: hashContent(content), notes };
 }
 function groundFileGlobs(content, treePaths) {
@@ -14603,10 +14823,10 @@ 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_fs13.existsSync)(domainDir)) continue;
+    const domainDir = (0, import_node_path13.join)(memoryDir2(), domain);
+    if (!(0, import_node_fs14.existsSync)(domainDir)) continue;
     try {
-      const files = await (0, import_promises8.readdir)(domainDir);
+      const files = await (0, import_promises9.readdir)(domainDir);
       const mdFiles = files.filter((f) => f.endsWith(".md"));
       if (mdFiles.length === 0) continue;
       lines.push(`## ${domain}/ (${mdFiles.length})`);
@@ -14614,7 +14834,7 @@ async function regenerateIndex() {
       for (const file of mdFiles.sort()) {
         const slug = file.replace(/\.md$/, "");
         try {
-          const content = await (0, import_promises8.readFile)((0, import_node_path12.join)(domainDir, file), "utf-8");
+          const content = await (0, import_promises9.readFile)((0, import_node_path13.join)(domainDir, file), "utf-8");
           const title = pickFrontmatter(content, "title") ?? slug;
           const kind = pickFrontmatter(content, "kind") ?? "-";
           const confidence = pickFrontmatter(content, "confidence");
@@ -14638,14 +14858,14 @@ async function regenerateIndex() {
     lines.push("No nodes yet. Run an analysis to start building the knowledge graph.");
   }
   const next = lines.join("\n") + "\n";
-  const indexPath = (0, import_node_path12.join)(memoryDir2(), "index.md");
+  const indexPath = (0, import_node_path13.join)(memoryDir2(), "index.md");
   let existing = null;
   try {
-    existing = await (0, import_promises8.readFile)(indexPath, "utf-8");
+    existing = await (0, import_promises9.readFile)(indexPath, "utf-8");
   } catch {
   }
   if (existing === next) return;
-  await (0, import_promises8.writeFile)(indexPath, next);
+  await (0, import_promises9.writeFile)(indexPath, next);
 }
 function pickFrontmatter(content, key) {
   const re = new RegExp(`^${key}:\\s*"?([^"\\n]+?)"?\\s*$`, "m");
@@ -14672,6 +14892,90 @@ var LEGACY_MD_END = "<!-- gate-memory:end -->";
 var LEGACY_PRESERVE_START = "<!-- gate-memory:preserve -->";
 var LEGACY_PRESERVE_END = "<!-- /gate-memory:preserve -->";
 var CLAUDE_MD_PROSE = [
+  "## Project Memory",
+  "",
+  "This project has a knowledge graph maintained at `.verity/memory/`. Before starting",
+  "non-trivial work, scan `.verity/memory/index.md` for decisions, gotchas, and patterns",
+  "that may apply to the change you are about to make. Open specific node files via",
+  "the Read tool when the title or scope suggests relevance.",
+  "",
+  "The graph is auto-maintained by Verity. Files at `.verity/memory/_archive/` are",
+  "superseded \u2014 ignore them unless investigating history.",
+  "",
+  "Knowledge the organization's other repositories learned is mirrored outside the",
+  "repo at `~/.verity/orgs/<host>/<owner>/memory/` (`verity memory org` lists it).",
+  "Each claim says where it came from; one that is wrong here is demoted for",
+  'everyone with `verity memory demote <id> --reason "\u2026"`.',
+  "",
+  "## Quality gate: accepted risks",
+  "",
+  "When the Verity pre-commit/pre-push gate FAILs, fix the findings \u2014 that is the",
+  'default. Use `verity waive <pattern-id> --file <path> --reason "\u2026"` ONLY to relay',
+  "a risk a human has explicitly accepted: a named code-review finding, an ADR, or",
+  "the user saying so in this conversation. The --reason must cite that source.",
+  "",
+  "Never waive on your own judgment, to get past a block, or pre-emptively. A waive",
+  "binds to the file's current bytes and voids automatically when the file changes,",
+  "and every waive is recorded in the run ledger. For a pattern-level false positive",
+  "use `verity feedback finding <run-id> <pattern-id> false_positive` instead.",
+  "",
+  "## Post-task reflection",
+  "",
+  `When a task is complete (you've created a PR, the user says "done" or "ship it",`,
+  "or the work is clearly finished), **draft the reflection yourself** \u2014 1\u20133",
+  "concrete things worth remembering (a decision, a gotcha, or a pattern), each",
+  "cited with the files / PR / commands / error-signatures it came from. Skip",
+  "entirely if nothing non-obvious happened \u2014 that judgement is the ONLY filter,",
+  "because nothing reviews the reflection before it lands.",
+  "",
+  "Then record it straight away. There is no confirm step, in any environment:",
+  "",
+  "```bash",
+  'verity reflect --user-input "<your draft>" --kind <kind>',
+  "```",
+  "",
+  "Add `--confirmed` ONLY when the user authored or dictated the words. Without",
+  "it the node is stored as `source: agent` \u2014 Verity thought this, nobody checked",
+  "it. With it, `source: user` at full confidence \u2014 a person stands behind this.",
+  "Never claim the second for your own draft, however good it is.",
+  "",
+  "**Name the files in the text.** Verity scopes the reflection to the paths it",
+  "cites, and a reflection that names no file in this repo is never retrieved for",
+  "a later review \u2014 it is recorded and then invisible. The command says so when it",
+  'happens; `--file-globs "<path or glob>"` is the fix when the prose cannot carry',
+  "the paths.",
+  "",
+  "Then tell the user, in one line, what you recorded and where: the command",
+  "prints the node id, the path under `.verity/memory/`, and a dashboard link.",
+  "They did not agree to it in advance, so say it happened \u2014 editing or deleting",
+  "that file is how they correct it.",
+  "",
+  "> Durable, hand-curated guidance goes in the preserve region below (it survives",
+  "> regeneration) or anywhere OUTSIDE these markers. Everything else between the",
+  "> markers is tool-owned and overwritten on each run.",
+  "",
+  "## Housekeeping Turns",
+  "",
+  "When a turn will be pure housekeeping \u2014 pulling, installing dependencies,",
+  "rebasing, a formatting sweep you are not authoring \u2014 declare it BEFORE doing it:",
+  "",
+  "```bash",
+  'verity ignore --turn --agent --reason "pulling latest before starting"',
+  "```",
+  "",
+  "This skips the review for that turn, which saves the turn Verity would",
+  "otherwise spend saying it had nothing to say. Use `--for 30m` instead of",
+  "`--turn` when a single piece of housekeeping spans several turns.",
+  "",
+  "**It is a claim about the turn, not a way to silence review.** The declaration",
+  "is checked against what the turn actually did: if anything is authored \u2014 by you,",
+  "by a subagent, or by a shell command that can write files \u2014 it voids, the review",
+  "runs anyway, and the broken declaration is reported. So declare housekeeping you",
+  "are about to do, never work you have already done, and never as a way to get past",
+  "a finding. Declarations are budgeted per session and every one is recorded with",
+  "its reason."
+].join("\n");
+var CLAUDE_MD_PROSE_PRE_ORG = [
   "## Project Memory",
   "",
   "This project has a knowledge graph maintained at `.verity/memory/`. Before starting",
@@ -14951,10 +15255,10 @@ function hasLegacyMemoryBlock(text) {
   return findMarker(text, LEGACY_MD_START) !== -1;
 }
 async function ensureClaudeMdPointer(cwd = repoRoot()) {
-  const claudeMdPath = (0, import_node_path12.join)(cwd, "CLAUDE.md");
+  const claudeMdPath = (0, import_node_path13.join)(cwd, "CLAUDE.md");
   let existing = "";
-  if ((0, import_node_fs13.existsSync)(claudeMdPath)) {
-    existing = await (0, import_promises8.readFile)(claudeMdPath, "utf-8");
+  if ((0, import_node_fs14.existsSync)(claudeMdPath)) {
+    existing = await (0, import_promises9.readFile)(claudeMdPath, "utf-8");
   }
   let startTag = CLAUDE_MD_START;
   let endTag = CLAUDE_MD_END;
@@ -15010,7 +15314,7 @@ async function ensureClaudeMdPointer(cwd = repoRoot()) {
     next = existing.replace(/\n*$/, "") + "\n\n" + block + "\n";
   }
   if (next === existing) return;
-  await (0, import_promises8.writeFile)(claudeMdPath, next);
+  await (0, import_promises9.writeFile)(claudeMdPath, next);
 }
 function extractPreserveContent(interior) {
   for (const [start, end] of [
@@ -15029,6 +15333,7 @@ function stripKnownProse(interior) {
   const trimmed = interior.replace(/^\n+/, "");
   for (const prose of [
     CLAUDE_MD_PROSE,
+    CLAUDE_MD_PROSE_PRE_ORG,
     CLAUDE_MD_PROSE_PRE_AUTORECORD,
     CLAUDE_MD_PROSE_PRE_REFLECT,
     CLAUDE_MD_PROSE_PRE_WAIVE,
@@ -15093,9 +15398,9 @@ Body content (\u22648KB). Use [[node-id]] wikilinks for cross-references.
 `;
 
 // src/lib/dossier-session.ts
-var import_node_fs18 = require("node:fs");
+var import_node_fs19 = require("node:fs");
 var import_node_crypto7 = require("node:crypto");
-var import_node_path15 = require("node:path");
+var import_node_path16 = require("node:path");
 
 // src/lib/pending-repeat.ts
 var STOP = /* @__PURE__ */ new Set([
@@ -15200,8 +15505,8 @@ function statementAnchorKey(file, patternId) {
 
 // src/lib/dossier/log.ts
 var import_node_crypto4 = require("node:crypto");
-var import_node_fs14 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_fs15 = require("node:fs");
+var import_node_path14 = require("node:path");
 var CRC_TABLE = (() => {
   const t = new Int32Array(256);
   for (let i = 0; i < 256; i++) {
@@ -15220,13 +15525,13 @@ function crc32(s) {
 function openDossier(identity) {
   try {
     const dir = dossierDir(identity);
-    (0, import_node_fs14.mkdirSync)(dir, { recursive: true, mode: 448 });
+    (0, import_node_fs15.mkdirSync)(dir, { recursive: true, mode: 448 });
     return {
       dir,
       identity,
-      eventsPath: (0, import_node_path13.join)(dir, "events.jsonl"),
-      foldPath: (0, import_node_path13.join)(dir, "fold.json"),
-      rotatedDir: (0, import_node_path13.join)(dir, "rotated")
+      eventsPath: (0, import_node_path14.join)(dir, "events.jsonl"),
+      foldPath: (0, import_node_path14.join)(dir, "fold.json"),
+      rotatedDir: (0, import_node_path14.join)(dir, "rotated")
     };
   } catch {
     return null;
@@ -15288,7 +15593,7 @@ function appendEvent(d, ev) {
       at: ev.at ?? (/* @__PURE__ */ new Date()).toISOString(),
       ...ev
     });
-    (0, import_node_fs14.appendFileSync)(d.eventsPath, line, { mode: 384 });
+    (0, import_node_fs15.appendFileSync)(d.eventsPath, line, { mode: 384 });
     return true;
   } catch {
     return false;
@@ -15296,14 +15601,14 @@ function appendEvent(d, ev) {
 }
 function rotateIfNeeded2(d) {
   try {
-    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();
+    if (!(0, import_node_fs15.existsSync)(d.eventsPath)) return;
+    if ((0, import_node_fs15.statSync)(d.eventsPath).size < ROTATE_BYTES) return;
+    (0, import_node_fs15.mkdirSync)(d.rotatedDir, { recursive: true, mode: 448 });
+    (0, import_node_fs15.renameSync)(d.eventsPath, (0, import_node_path14.join)(d.rotatedDir, `events.${Date.now()}.jsonl`));
+    const kept = (0, import_node_fs15.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_fs14.renameSync)((0, import_node_path13.join)(d.rotatedDir, stale), (0, import_node_path13.join)(d.rotatedDir, `${stale}.pruned`));
+        (0, import_node_fs15.renameSync)((0, import_node_path14.join)(d.rotatedDir, stale), (0, import_node_path14.join)(d.rotatedDir, `${stale}.pruned`));
       } catch {
       }
     }
@@ -15313,8 +15618,8 @@ function rotateIfNeeded2(d) {
 
 // src/lib/dossier/fold-dossier.ts
 var import_node_crypto5 = require("node:crypto");
-var import_node_fs15 = require("node:fs");
-var import_node_path14 = require("node:path");
+var import_node_fs16 = require("node:fs");
+var import_node_path15 = require("node:path");
 var EMPTY_CAPABILITIES = () => ({
   human_reachable: { value: "unknown", tier: "unknown" },
   authorship_observability: { value: "unknown", tier: "unknown" },
@@ -15365,12 +15670,12 @@ function foldDossier(d, opts = {}) {
     }
   };
   try {
-    if ((0, import_node_fs15.existsSync)(d.rotatedDir)) {
-      const files = (0, import_node_fs15.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).sort();
+    if ((0, import_node_fs16.existsSync)(d.rotatedDir)) {
+      const files = (0, import_node_fs16.readdirSync)(d.rotatedDir).filter((f) => f.endsWith(".jsonl")).sort();
       state.meta.rotations = files.length;
       for (const f of files) {
         try {
-          ingest((0, import_node_fs15.readFileSync)((0, import_node_path14.join)(d.rotatedDir, f), "utf8"));
+          ingest((0, import_node_fs16.readFileSync)((0, import_node_path15.join)(d.rotatedDir, f), "utf8"));
         } catch {
           state.meta.dropped_lines++;
         }
@@ -15379,9 +15684,9 @@ function foldDossier(d, opts = {}) {
   } catch {
   }
   try {
-    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"));
+    if ((0, import_node_fs16.existsSync)(d.eventsPath)) {
+      state.meta.upto_offset = (0, import_node_fs16.statSync)(d.eventsPath).size;
+      ingest((0, import_node_fs16.readFileSync)(d.eventsPath, "utf8"));
     }
   } catch {
   }
@@ -15652,7 +15957,7 @@ function applyBounds(state, input) {
 }
 
 // src/lib/dossier/cache.ts
-var import_node_fs16 = require("node:fs");
+var import_node_fs17 = require("node:fs");
 function compactState(s) {
   const ms = (iso) => Date.parse(iso) || 0;
   return {
@@ -15781,20 +16086,20 @@ function encodeState(s) {
 function writeFoldCache(d, state) {
   try {
     const tmp = `${d.foldPath}.${process.pid}.tmp`;
-    (0, import_node_fs16.writeFileSync)(tmp, encodeState(state), { mode: 384 });
-    (0, import_node_fs16.renameSync)(tmp, d.foldPath);
+    (0, import_node_fs17.writeFileSync)(tmp, encodeState(state), { mode: 384 });
+    (0, import_node_fs17.renameSync)(tmp, d.foldPath);
   } catch {
   }
 }
 function readFoldCache(d) {
   try {
-    if (!(0, import_node_fs16.existsSync)(d.foldPath)) return null;
-    const raw = JSON.parse((0, import_node_fs16.readFileSync)(d.foldPath, "utf8"));
+    if (!(0, import_node_fs17.existsSync)(d.foldPath)) return null;
+    const raw = JSON.parse((0, import_node_fs17.readFileSync)(d.foldPath, "utf8"));
     if (raw?.v !== 1) return null;
     const cached2 = expandState(raw);
     if (!cached2?.meta) return null;
-    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;
+    const size = (0, import_node_fs17.existsSync)(d.eventsPath) ? (0, import_node_fs17.statSync)(d.eventsPath).size : 0;
+    const rotations = (0, import_node_fs17.existsSync)(d.rotatedDir) ? (0, import_node_fs17.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 {
@@ -15845,13 +16150,13 @@ function assessContinuity(i) {
 
 // src/lib/dossier/reanchor.ts
 var import_node_crypto6 = require("node:crypto");
-var import_node_fs17 = require("node:fs");
+var import_node_fs18 = 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_fs17.readFileSync)(path)).digest("hex").slice(0, HASH_WIDTH);
+    return (0, import_node_crypto6.createHash)("sha256").update((0, import_node_fs18.readFileSync)(path)).digest("hex").slice(0, HASH_WIDTH);
   } catch {
     return null;
   }
@@ -16223,20 +16528,20 @@ function foreignAuthoredPaths(identity, opts = {}) {
   let sessions = 0;
   try {
     const dir = treeDir(identity);
-    if (!(0, import_node_fs18.existsSync)(dir)) return { paths: [], sessions: 0 };
-    for (const entry of (0, import_node_fs18.readdirSync)(dir, { withFileTypes: true })) {
+    if (!(0, import_node_fs19.existsSync)(dir)) return { paths: [], sessions: 0 };
+    for (const entry of (0, import_node_fs19.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");
+      const log = (0, import_node_path16.join)(dir, entry.name, "events.jsonl");
       try {
-        if (!(0, import_node_fs18.existsSync)(log)) continue;
-        if (now - (0, import_node_fs18.statSync)(log).mtimeMs > windowMs) continue;
+        if (!(0, import_node_fs19.existsSync)(log)) continue;
+        if (now - (0, import_node_fs19.statSync)(log).mtimeMs > windowMs) continue;
         const sib = {
-          dir: (0, import_node_path15.join)(dir, entry.name),
+          dir: (0, import_node_path16.join)(dir, entry.name),
           identity,
           eventsPath: log,
-          foldPath: (0, import_node_path15.join)(dir, entry.name, "fold.json"),
-          rotatedDir: (0, import_node_path15.join)(dir, entry.name, "rotated")
+          foldPath: (0, import_node_path16.join)(dir, entry.name, "fold.json"),
+          rotatedDir: (0, import_node_path16.join)(dir, entry.name, "rotated")
         };
         const state = readFoldCache(sib) ?? foldDossier(sib);
         sessions++;
@@ -16264,25 +16569,25 @@ function pruneOldDossiers(identity, maxAgeMs = 7 * 24 * 60 * 60 * 1e3) {
   let removed = 0;
   try {
     const mine = dossierDir(identity);
-    const userDir = (0, import_node_path15.dirname)((0, import_node_path15.dirname)(mine));
-    if (!(0, import_node_fs18.existsSync)(userDir)) return 0;
+    const userDir = (0, import_node_path16.dirname)((0, import_node_path16.dirname)(mine));
+    if (!(0, import_node_fs19.existsSync)(userDir)) return 0;
     const cutoff = Date.now() - maxAgeMs;
-    for (const tree of (0, import_node_fs18.readdirSync)(userDir, { withFileTypes: true })) {
+    for (const tree of (0, import_node_fs19.readdirSync)(userDir, { withFileTypes: true })) {
       if (!tree.isDirectory()) continue;
-      const treePath = (0, import_node_path15.join)(userDir, tree.name);
+      const treePath = (0, import_node_path16.join)(userDir, tree.name);
       let live = 0;
-      for (const entry of (0, import_node_fs18.readdirSync)(treePath, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs19.readdirSync)(treePath, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const dir = (0, import_node_path15.join)(treePath, entry.name);
+        const dir = (0, import_node_path16.join)(treePath, entry.name);
         if (dir === mine) {
           live++;
           continue;
         }
         try {
-          const log = (0, import_node_path15.join)(dir, "events.jsonl");
-          const at = (0, import_node_fs18.existsSync)(log) ? (0, import_node_fs18.statSync)(log).mtimeMs : (0, import_node_fs18.statSync)(dir).mtimeMs;
+          const log = (0, import_node_path16.join)(dir, "events.jsonl");
+          const at = (0, import_node_fs19.existsSync)(log) ? (0, import_node_fs19.statSync)(log).mtimeMs : (0, import_node_fs19.statSync)(dir).mtimeMs;
           if (at < cutoff) {
-            (0, import_node_fs18.rmSync)(dir, { recursive: true, force: true });
+            (0, import_node_fs19.rmSync)(dir, { recursive: true, force: true });
             removed++;
           } else {
             live++;
@@ -16292,7 +16597,7 @@ function pruneOldDossiers(identity, maxAgeMs = 7 * 24 * 60 * 60 * 1e3) {
       }
       if (live === 0) {
         try {
-          (0, import_node_fs18.rmSync)(treePath, { recursive: false, force: false });
+          (0, import_node_fs19.rmSync)(treePath, { recursive: false, force: false });
         } catch {
         }
       }
@@ -16309,8 +16614,8 @@ function sessionDossier(token, sessionId) {
 }
 function hasActiveGoal(d) {
   try {
-    if (!(0, import_node_fs18.existsSync)(d.eventsPath)) return false;
-    return (0, import_node_fs18.readFileSync)(d.eventsPath, "utf8").includes('"k":"goal"');
+    if (!(0, import_node_fs19.existsSync)(d.eventsPath)) return false;
+    return (0, import_node_fs19.readFileSync)(d.eventsPath, "utf8").includes('"k":"goal"');
   } catch {
     return false;
   }
@@ -16334,7 +16639,7 @@ function recordTurn(d, t) {
   for (const a of t.authored) {
     const origin = a.owner === "subagent" ? "subagent" : "edit_tool";
     const prior = t.known?.authored?.get(a.p);
-    const hash = fileHash((0, import_node_path15.join)(root, a.p));
+    const hash = fileHash((0, import_node_path16.join)(root, a.p));
     const hunks = Math.max(0, a.h - (prior?.hunks ?? 0));
     const adds = Math.max(0, a.a - (prior?.adds ?? 0));
     const dels = Math.max(0, a.d - (prior?.dels ?? 0));
@@ -16367,7 +16672,7 @@ function recordTurn(d, t) {
   }
   const seenDivergence = t.known?.divergence ?? /* @__PURE__ */ new Set();
   for (const u of t.unobserved) {
-    const hash = fileHash((0, import_node_path15.join)(root, u.p));
+    const hash = fileHash((0, import_node_path16.join)(root, u.p));
     if (seenDivergence.has(divergenceKey(u.p, hash))) continue;
     appendEvent(d, { k: "divergence", kind: "external_mutation", path: u.p, hash });
   }
@@ -16402,8 +16707,8 @@ function recordVerdict(d, v) {
     if (!sent.has(f.file)) continue;
     if (!lines.has(f.file)) {
       try {
-        const abs = (0, import_node_path15.join)(root, f.file);
-        lines.set(f.file, (0, import_node_fs18.existsSync)(abs) ? (0, import_node_fs18.readFileSync)(abs, "utf8").split("\n") : null);
+        const abs = (0, import_node_path16.join)(root, f.file);
+        lines.set(f.file, (0, import_node_fs19.existsSync)(abs) ? (0, import_node_fs19.readFileSync)(abs, "utf8").split("\n") : null);
       } catch {
         lines.set(f.file, null);
       }
@@ -16503,8 +16808,8 @@ function recallMemory(d, identity, opts) {
       budgetBytes: opts.budgetBytes,
       readFileLines: (file) => {
         try {
-          const abs = (0, import_node_path15.join)(root, file);
-          return (0, import_node_fs18.existsSync)(abs) ? (0, import_node_fs18.readFileSync)(abs, "utf8").split("\n") : null;
+          const abs = (0, import_node_path16.join)(root, file);
+          return (0, import_node_fs19.existsSync)(abs) ? (0, import_node_fs19.readFileSync)(abs, "utf8").split("\n") : null;
         } catch {
           return null;
         }
@@ -16648,46 +16953,46 @@ async function fireClassify(prompt, sessionId, globals) {
 }
 
 // src/commands/lifecycle.ts
-var import_node_fs22 = require("node:fs");
-var import_node_path20 = require("node:path");
+var import_node_fs23 = require("node:fs");
+var import_node_path21 = require("node:path");
 
 // src/lib/baseline.ts
-var import_node_fs21 = require("node:fs");
-var import_node_path19 = require("node:path");
+var import_node_fs22 = require("node:fs");
+var import_node_path20 = require("node:path");
 var import_node_crypto9 = require("node:crypto");
 
 // src/lib/snapshot.ts
-var import_node_fs20 = require("node:fs");
-var import_node_path18 = require("node:path");
+var import_node_fs21 = require("node:fs");
+var import_node_path19 = require("node:path");
 var import_node_child_process7 = require("node:child_process");
 
 // src/lib/files.ts
-var import_node_path17 = require("node:path");
+var import_node_path18 = require("node:path");
 
 // src/lib/safe-read.ts
-var import_node_fs19 = require("node:fs");
-var import_node_path16 = require("node:path");
-var FLAGS = import_node_fs19.constants;
+var import_node_fs20 = require("node:fs");
+var import_node_path17 = require("node:path");
+var FLAGS = import_node_fs20.constants;
 var NOFOLLOW = FLAGS.O_NOFOLLOW;
 var NONBLOCK = FLAGS.O_NONBLOCK;
 function closeOpened(fd) {
   try {
-    (0, import_node_fs19.closeSync)(fd);
+    (0, import_node_fs20.closeSync)(fd);
   } catch {
   }
 }
 function isInsideRoot(realRoot, realPath) {
-  return realPath === realRoot || realPath.startsWith(realRoot.endsWith(import_node_path16.sep) ? realRoot : realRoot + import_node_path16.sep);
+  return realPath === realRoot || realPath.startsWith(realRoot.endsWith(import_node_path17.sep) ? realRoot : realRoot + import_node_path17.sep);
 }
 function sameOpenedFile(opened, current, nofollowAvailable) {
   if (!nofollowAvailable && (opened.ino === 0n || current.ino === 0n)) return false;
   return opened.ino === current.ino && opened.dev === current.dev;
 }
 function openRegularInRoot(root, path) {
-  const full = (0, import_node_path16.isAbsolute)(path) ? path : (0, import_node_path16.join)(root, path);
+  const full = (0, import_node_path17.isAbsolute)(path) ? path : (0, import_node_path17.join)(root, path);
   let fd;
   try {
-    fd = (0, import_node_fs19.openSync)(full, import_node_fs19.constants.O_RDONLY | (NOFOLLOW ?? 0) | (NONBLOCK ?? 0));
+    fd = (0, import_node_fs20.openSync)(full, import_node_fs20.constants.O_RDONLY | (NOFOLLOW ?? 0) | (NONBLOCK ?? 0));
   } catch (err) {
     const code = err.code;
     if (code === "ELOOP" || code === "EMLINK" || code === "EFTYPE") return { ok: false, reason: "symlink" };
@@ -16695,18 +17000,18 @@ function openRegularInRoot(root, path) {
     return { ok: false, reason: "unreadable" };
   }
   try {
-    const opened = (0, import_node_fs19.fstatSync)(fd, { bigint: true });
+    const opened = (0, import_node_fs20.fstatSync)(fd, { bigint: true });
     if (!opened.isFile()) {
       closeOpened(fd);
       return { ok: false, reason: "not-regular" };
     }
-    const realRoot = import_node_fs19.realpathSync.native(root);
-    const realPath = import_node_fs19.realpathSync.native(full);
+    const realRoot = import_node_fs20.realpathSync.native(root);
+    const realPath = import_node_fs20.realpathSync.native(full);
     if (!isInsideRoot(realRoot, realPath)) {
       closeOpened(fd);
       return { ok: false, reason: "outside-root" };
     }
-    const current = (0, import_node_fs19.statSync)(realPath, { bigint: true });
+    const current = (0, import_node_fs20.statSync)(realPath, { bigint: true });
     if (!sameOpenedFile(opened, current, NOFOLLOW !== void 0)) {
       closeOpened(fd);
       return { ok: false, reason: NOFOLLOW === void 0 ? "unreadable" : "outside-root" };
@@ -16728,7 +17033,7 @@ function readOpened(fd, size) {
     const buffer = Buffer.alloc(size);
     let offset = 0;
     while (offset < size) {
-      const n = (0, import_node_fs19.readSync)(fd, buffer, offset, size - offset, offset);
+      const n = (0, import_node_fs20.readSync)(fd, buffer, offset, size - offset, offset);
       if (n === 0) break;
       offset += n;
     }
@@ -16822,7 +17127,7 @@ var LANG_MAP = {
   mk: "make"
 };
 function detectLanguage(filepath) {
-  const ext = (0, import_node_path17.extname)(filepath).slice(1);
+  const ext = (0, import_node_path18.extname)(filepath).slice(1);
   return LANG_MAP[ext] ?? ext;
 }
 function sortByMtime(files) {
@@ -16913,16 +17218,16 @@ function collectCodeDelta(files, opts) {
 
 // src/lib/snapshot.ts
 function generateSnapshotDiffs(files) {
-  if (!(0, import_node_fs20.existsSync)(SNAPSHOT_DIR)) {
+  if (!(0, import_node_fs21.existsSync)(SNAPSHOT_DIR)) {
     return { diffs: [], has_snapshots: false };
   }
   const diffs = [];
   for (const file of files) {
     if (!resolveInside(SNAPSHOT_DIR, file.path)) continue;
-    const snapshotPath = (0, import_node_path18.join)(SNAPSHOT_DIR, file.path);
+    const snapshotPath = (0, import_node_path19.join)(SNAPSHOT_DIR, file.path);
     const language = file.language ?? detectLanguage(file.path);
-    if ((0, import_node_fs20.existsSync)(snapshotPath)) {
-      const oldContent = (0, import_node_fs20.readFileSync)(snapshotPath, "utf-8");
+    if ((0, import_node_fs21.existsSync)(snapshotPath)) {
+      const oldContent = (0, import_node_fs21.readFileSync)(snapshotPath, "utf-8");
       if (oldContent === file.content) continue;
       const diff = computeDiff(oldContent, file.content, file.path);
       if (diff) {
@@ -16947,20 +17252,20 @@ function saveSnapshots(files) {
   const snapshotPaths = /* @__PURE__ */ new Set();
   for (const file of files) {
     if (!resolveInside(SNAPSHOT_DIR, file.path)) continue;
-    const snapshotPath = (0, import_node_path18.join)(SNAPSHOT_DIR, file.path);
+    const snapshotPath = (0, import_node_path19.join)(SNAPSHOT_DIR, file.path);
     snapshotPaths.add(snapshotPath);
-    (0, import_node_fs20.mkdirSync)((0, import_node_path18.dirname)(snapshotPath), { recursive: true });
-    (0, import_node_fs20.writeFileSync)(snapshotPath, file.content);
+    (0, import_node_fs21.mkdirSync)((0, import_node_path19.dirname)(snapshotPath), { recursive: true });
+    (0, import_node_fs21.writeFileSync)(snapshotPath, file.content);
   }
   cleanStaleSnapshots(SNAPSHOT_DIR, snapshotPaths);
 }
 function computeDiff(oldContent, newContent, filePath) {
-  const tmpOld = (0, import_node_path18.join)(SNAPSHOT_DIR, ".diff-old.tmp");
-  const tmpNew = (0, import_node_path18.join)(SNAPSHOT_DIR, ".diff-new.tmp");
+  const tmpOld = (0, import_node_path19.join)(SNAPSHOT_DIR, ".diff-old.tmp");
+  const tmpNew = (0, import_node_path19.join)(SNAPSHOT_DIR, ".diff-new.tmp");
   try {
-    (0, import_node_fs20.mkdirSync)(SNAPSHOT_DIR, { recursive: true });
-    (0, import_node_fs20.writeFileSync)(tmpOld, oldContent);
-    (0, import_node_fs20.writeFileSync)(tmpNew, newContent);
+    (0, import_node_fs21.mkdirSync)(SNAPSHOT_DIR, { recursive: true });
+    (0, import_node_fs21.writeFileSync)(tmpOld, oldContent);
+    (0, import_node_fs21.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"] }
@@ -16974,32 +17279,32 @@ function computeDiff(oldContent, newContent, filePath) {
     return null;
   } finally {
     try {
-      (0, import_node_fs20.unlinkSync)(tmpOld);
+      (0, import_node_fs21.unlinkSync)(tmpOld);
     } catch {
     }
     try {
-      (0, import_node_fs20.unlinkSync)(tmpNew);
+      (0, import_node_fs21.unlinkSync)(tmpNew);
     } catch {
     }
   }
 }
 function cleanStaleSnapshots(dir, keepSet) {
-  if (!(0, import_node_fs20.existsSync)(dir)) return;
+  if (!(0, import_node_fs21.existsSync)(dir)) return;
   try {
-    const entries = (0, import_node_fs20.readdirSync)(dir, { withFileTypes: true });
+    const entries = (0, import_node_fs21.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_path18.join)(dir, entry.name);
+      const fullPath = (0, import_node_path19.join)(dir, entry.name);
       if (entry.isDirectory()) {
         cleanStaleSnapshots(fullPath, keepSet);
         try {
-          const remaining = (0, import_node_fs20.readdirSync)(fullPath);
-          if (remaining.length === 0) (0, import_node_fs20.rmdirSync)(fullPath);
+          const remaining = (0, import_node_fs21.readdirSync)(fullPath);
+          if (remaining.length === 0) (0, import_node_fs21.rmdirSync)(fullPath);
         } catch {
         }
       } else if (!keepSet.has(fullPath)) {
         try {
-          (0, import_node_fs20.unlinkSync)(fullPath);
+          (0, import_node_fs21.unlinkSync)(fullPath);
         } catch {
         }
       }
@@ -17018,20 +17323,20 @@ function sessionKey(sessionId) {
   return (0, import_node_crypto9.createHash)("sha256").update(sessionId).digest("hex").slice(0, 16);
 }
 function sessionDir(key) {
-  return (0, import_node_path19.join)(projectPath(BASELINE_DIR), key);
+  return (0, import_node_path20.join)(projectPath(BASELINE_DIR), key);
 }
 function manifestPath(dir) {
-  return (0, import_node_path19.join)(dir, "manifest.json");
+  return (0, import_node_path20.join)(dir, "manifest.json");
 }
 function mirrorPath(dir, repoRelPath) {
-  return (0, import_node_path19.join)(dir, "files", repoRelPath);
+  return (0, import_node_path20.join)(dir, "files", repoRelPath);
 }
 var CARRY_FILE = `${BASELINE_DIR}/.carry`;
 var CARRY_WINDOW_MS = 12e4;
 function writeCarry(sessionId, headSha) {
   try {
-    (0, import_node_fs21.mkdirSync)(projectPath(BASELINE_DIR), { recursive: true });
-    (0, import_node_fs21.writeFileSync)(
+    (0, import_node_fs22.mkdirSync)(projectPath(BASELINE_DIR), { recursive: true });
+    (0, import_node_fs22.writeFileSync)(
       projectPath(CARRY_FILE),
       JSON.stringify({ from_key: sessionKey(sessionId), head_sha: headSha, ts: Date.now() })
     );
@@ -17041,10 +17346,10 @@ function writeCarry(sessionId, headSha) {
 function claimCarry(newKey) {
   const carryPath = projectPath(CARRY_FILE);
   try {
-    if (!(0, import_node_fs21.existsSync)(carryPath)) return null;
-    const carry = JSON.parse((0, import_node_fs21.readFileSync)(carryPath, "utf-8"));
+    if (!(0, import_node_fs22.existsSync)(carryPath)) return null;
+    const carry = JSON.parse((0, import_node_fs22.readFileSync)(carryPath, "utf-8"));
     try {
-      (0, import_node_fs21.rmSync)(carryPath, { force: true });
+      (0, import_node_fs22.rmSync)(carryPath, { force: true });
     } catch {
     }
     if (!carry?.from_key || typeof carry.ts !== "number") return null;
@@ -17055,11 +17360,11 @@ function claimCarry(newKey) {
     if (!prior) return null;
     const toDir = sessionDir(newKey);
     try {
-      (0, import_node_fs21.rmSync)(toDir, { recursive: true, force: true });
+      (0, import_node_fs22.rmSync)(toDir, { recursive: true, force: true });
     } catch {
     }
-    (0, import_node_fs21.renameSync)(fromDir, toDir);
-    (0, import_node_fs21.writeFileSync)(manifestPath(toDir), JSON.stringify({ ...prior, session_id: newKey }) + "\n");
+    (0, import_node_fs22.renameSync)(fromDir, toDir);
+    (0, import_node_fs22.writeFileSync)(manifestPath(toDir), JSON.stringify({ ...prior, session_id: newKey }) + "\n");
     return readManifest(toDir);
   } catch {
     return null;
@@ -17083,21 +17388,21 @@ function captureBaseline(opts = {}) {
   const head_sha = getCurrentCommit();
   const dirty = getDirtyFiles();
   try {
-    (0, import_node_fs21.rmSync)(dir, { recursive: true, force: true });
+    (0, import_node_fs22.rmSync)(dir, { recursive: true, force: true });
   } catch {
   }
-  const filesDir = (0, import_node_path19.join)(dir, "files");
+  const filesDir = (0, import_node_path20.join)(dir, "files");
   const mirrored = [];
   try {
-    (0, import_node_fs21.mkdirSync)(filesDir, { recursive: true });
+    (0, import_node_fs22.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_fs21.mkdirSync)((0, import_node_path19.dirname)(dest), { recursive: true });
-        (0, import_node_fs21.writeFileSync)(dest, content);
+        (0, import_node_fs22.mkdirSync)((0, import_node_path20.dirname)(dest), { recursive: true });
+        (0, import_node_fs22.writeFileSync)(dest, content);
         mirrored.push(p);
       } catch {
       }
@@ -17112,8 +17417,8 @@ function captureBaseline(opts = {}) {
     version: BASELINE_VERSION
   };
   try {
-    (0, import_node_fs21.mkdirSync)(dir, { recursive: true });
-    (0, import_node_fs21.writeFileSync)(manifestPath(dir), JSON.stringify(baseline));
+    (0, import_node_fs22.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs22.writeFileSync)(manifestPath(dir), JSON.stringify(baseline));
   } catch {
   }
   pruneOldBaselines();
@@ -17124,9 +17429,9 @@ function readBaseline(sessionId) {
 }
 function readManifest(dir) {
   const mp = manifestPath(dir);
-  if (!(0, import_node_fs21.existsSync)(mp)) return null;
+  if (!(0, import_node_fs22.existsSync)(mp)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs21.readFileSync)(mp, "utf-8"));
+    const parsed = JSON.parse((0, import_node_fs22.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;
     }
@@ -17157,9 +17462,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_fs21.existsSync)(mp)) {
+    if ((0, import_node_fs22.existsSync)(mp)) {
       try {
-        return { content: (0, import_node_fs21.readFileSync)(mp, "utf-8"), existed: true };
+        return { content: (0, import_node_fs22.readFileSync)(mp, "utf-8"), existed: true };
       } catch {
       }
     }
@@ -17204,8 +17509,8 @@ function absorbIntoBaseline(paths, sessionId) {
       const content = safeReadForMirror(projectPath(p));
       if (content === null) continue;
       const dest = mirrorPath(dir, p);
-      (0, import_node_fs21.mkdirSync)((0, import_node_path19.dirname)(dest), { recursive: true });
-      (0, import_node_fs21.writeFileSync)(dest, content);
+      (0, import_node_fs22.mkdirSync)((0, import_node_path20.dirname)(dest), { recursive: true });
+      (0, import_node_fs22.writeFileSync)(dest, content);
       dirty.add(p);
       adopted++;
     } catch {
@@ -17214,7 +17519,7 @@ function absorbIntoBaseline(paths, sessionId) {
   if (adopted === 0) return 0;
   try {
     const updated = { ...baseline, dirty_paths: [...dirty] };
-    (0, import_node_fs21.writeFileSync)(manifestPath(dir), JSON.stringify(updated));
+    (0, import_node_fs22.writeFileSync)(manifestPath(dir), JSON.stringify(updated));
     preImageCache.delete(baseline);
   } catch {
     return 0;
@@ -17225,7 +17530,7 @@ function changedSinceBaseline(repoRelPath, baseline) {
   const pre = preImage(repoRelPath, baseline);
   let current;
   try {
-    current = (0, import_node_fs21.readFileSync)(projectPath(repoRelPath), "utf-8");
+    current = (0, import_node_fs22.readFileSync)(projectPath(repoRelPath), "utf-8");
   } catch {
     return pre.existed;
   }
@@ -17234,8 +17539,8 @@ function changedSinceBaseline(repoRelPath, baseline) {
 }
 function safeReadForMirror(absPath) {
   try {
-    if ((0, import_node_fs21.statSync)(absPath).size > MIRROR_MAX_BYTES) return null;
-    const buf = (0, import_node_fs21.readFileSync)(absPath);
+    if ((0, import_node_fs22.statSync)(absPath).size > MIRROR_MAX_BYTES) return null;
+    const buf = (0, import_node_fs22.readFileSync)(absPath);
     if (buf.includes(0)) return null;
     return buf.toString("utf-8");
   } catch {
@@ -17246,18 +17551,18 @@ function pruneOldBaselines() {
   const root = projectPath(BASELINE_DIR);
   let entries;
   try {
-    entries = (0, import_node_fs21.readdirSync)(root);
+    entries = (0, import_node_fs22.readdirSync)(root);
   } catch {
     return;
   }
   const now = Date.now();
   for (const name of entries) {
-    const dir = (0, import_node_path19.join)(root, name);
+    const dir = (0, import_node_path20.join)(root, name);
     const manifest = readManifest(dir);
     if (!manifest) {
       try {
-        if (now - (0, import_node_fs21.statSync)(dir).mtimeMs > BASELINE_TTL_MS) {
-          (0, import_node_fs21.rmSync)(dir, { recursive: true, force: true });
+        if (now - (0, import_node_fs22.statSync)(dir).mtimeMs > BASELINE_TTL_MS) {
+          (0, import_node_fs22.rmSync)(dir, { recursive: true, force: true });
         }
       } catch {
       }
@@ -17265,7 +17570,7 @@ function pruneOldBaselines() {
     }
     if (now - manifest.captured_at <= BASELINE_TTL_MS) continue;
     try {
-      (0, import_node_fs21.rmSync)(dir, { recursive: true, force: true });
+      (0, import_node_fs22.rmSync)(dir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -17440,8 +17745,8 @@ function buildCompactionContext(session) {
     commitsSince: commitsSincePaths(watermark, (state.authored ?? []).map((a) => a.path)),
     readFileLines: (file) => {
       try {
-        const abs = (0, import_node_path20.join)(root, file);
-        return (0, import_node_fs22.existsSync)(abs) ? (0, import_node_fs22.readFileSync)(abs, "utf8").split("\n") : null;
+        const abs = (0, import_node_path21.join)(root, file);
+        return (0, import_node_fs23.existsSync)(abs) ? (0, import_node_fs23.readFileSync)(abs, "utf8").split("\n") : null;
       } catch {
         return null;
       }
@@ -17497,25 +17802,25 @@ async function readHookStdin() {
 }
 
 // src/commands/standard.ts
-var import_promises12 = require("node:fs/promises");
-var import_node_fs29 = require("node:fs");
+var import_promises13 = require("node:fs/promises");
+var import_node_fs30 = require("node:fs");
 var import_yaml3 = __toESM(require_dist());
 
 // src/lib/synthesize.ts
 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_path23 = require("node:path");
+var import_node_fs26 = require("node:fs");
+var import_promises10 = require("node:fs/promises");
+var import_node_path24 = require("node:path");
 var import_yaml = __toESM(require_dist());
 
 // src/lib/data-dir.ts
-var import_node_fs23 = require("node:fs");
-var import_node_path21 = require("node:path");
+var import_node_fs24 = require("node:fs");
+var import_node_path22 = require("node:path");
 function resolveDataDir() {
   const candidates2 = [
-    (0, import_node_path21.join)(__dirname, "..", "data"),
+    (0, import_node_path22.join)(__dirname, "..", "data"),
     // installed: node_modules/@codacy/verity-cli/data
-    (0, import_node_path21.join)(__dirname, "..", "..", "data"),
+    (0, import_node_path22.join)(__dirname, "..", "..", "data"),
     // edge case: nested resolution
     // THE COMMITTED SOURCE, for a source checkout that has not been built.
     // cli/data/skills/ is a BUILD ARTIFACT (scripts/build.js copies client/skills
@@ -17524,14 +17829,14 @@ function resolveDataDir() {
     // without this the synthesizer throws "Could not find Verity skill data"
     // for every test and every `verity` run from source. Resolved from this
     // module's own location, never the cwd: see the warning below.
-    (0, import_node_path21.join)(__dirname, "..", "..", "client"),
+    (0, import_node_path22.join)(__dirname, "..", "..", "client"),
     // bundled: cli/bin/ → ../../client
-    (0, import_node_path21.join)(__dirname, "..", "..", "..", "client"),
+    (0, import_node_path22.join)(__dirname, "..", "..", "..", "client"),
     // tsx: cli/src/lib/ → ../../../client
     ...process.env.VERITY_DEV_DATA_DIR ? [process.env.VERITY_DEV_DATA_DIR] : []
   ];
   for (const candidate of candidates2) {
-    if ((0, import_node_fs23.existsSync)((0, import_node_path21.join)(candidate, "skills"))) {
+    if ((0, import_node_fs24.existsSync)((0, import_node_path22.join)(candidate, "skills"))) {
       return candidate;
     }
   }
@@ -17540,13 +17845,13 @@ function resolveDataDir() {
   );
 }
 function setupDataPath(file) {
-  return (0, import_node_path21.join)(resolveDataDir(), "skills", "verity-setup", file);
+  return (0, import_node_path22.join)(resolveDataDir(), "skills", "verity-setup", file);
 }
 
 // src/lib/detect.ts
 var import_node_child_process8 = require("node:child_process");
-var import_node_fs24 = require("node:fs");
-var import_node_path22 = require("node:path");
+var import_node_fs25 = require("node:fs");
+var import_node_path23 = require("node:path");
 var TOOLED_LANGUAGES = /* @__PURE__ */ new Set([
   "typescript",
   "javascript",
@@ -17603,25 +17908,25 @@ function walk(root) {
     if (depth > WALK_MAX_DEPTH || found.length >= WALK_MAX_FILES) return;
     let entries;
     try {
-      entries = (0, import_node_fs24.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs25.readdirSync)(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (found.length >= WALK_MAX_FILES) return;
       if (IGNORED_SEGMENTS.includes(entry.name)) continue;
-      const full = (0, import_node_path22.join)(dir, entry.name);
+      const full = (0, import_node_path23.join)(dir, entry.name);
       if (entry.isDirectory()) visit(full, depth + 1);
-      else if (entry.isFile()) found.push((0, import_node_path22.relative)(root, full));
+      else if (entry.isFile()) found.push((0, import_node_path23.relative)(root, full));
     }
   };
   visit(root, 0);
   return found;
 }
 function languageOf(path) {
-  const name = (0, import_node_path22.basename)(path);
+  const name = (0, import_node_path23.basename)(path);
   if (/^Dockerfile(\..+)?$/i.test(name)) return "dockerfile";
-  if (!(0, import_node_path22.extname)(name)) return null;
+  if (!(0, import_node_path23.extname)(name)) return null;
   const lang = detectLanguage(path);
   return lang || null;
 }
@@ -17678,7 +17983,7 @@ var TOOL_CONFIG_MARKERS = [
 ];
 function readJson(path) {
   try {
-    return JSON.parse((0, import_node_fs24.readFileSync)(path, "utf-8"));
+    return JSON.parse((0, import_node_fs25.readFileSync)(path, "utf-8"));
   } catch {
     return null;
   }
@@ -17703,17 +18008,17 @@ function declaredDependencies(root, files) {
       if (deps && typeof deps === "object") names2.push(...Object.keys(deps));
     }
   };
-  readPackageJson((0, import_node_path22.join)(root, "package.json"));
-  const nested = files.filter((f) => f.includes("/") && (0, import_node_path22.basename)(f) === "package.json").slice(0, NESTED_MANIFEST_LIMIT);
-  for (const rel of nested) readPackageJson((0, import_node_path22.join)(root, rel));
+  readPackageJson((0, import_node_path23.join)(root, "package.json"));
+  const nested = files.filter((f) => f.includes("/") && (0, import_node_path23.basename)(f) === "package.json").slice(0, NESTED_MANIFEST_LIMIT);
+  for (const rel of nested) readPackageJson((0, import_node_path23.join)(root, rel));
   const pythonManifests = [
-    ...["pyproject.toml", "requirements.txt", "Pipfile", "setup.py"].map((f) => (0, import_node_path22.join)(root, f)),
-    ...files.filter((f) => f.includes("/") && /(^|\/)(pyproject\.toml|requirements\.txt)$/.test(f)).slice(0, NESTED_MANIFEST_LIMIT).map((f) => (0, import_node_path22.join)(root, f))
+    ...["pyproject.toml", "requirements.txt", "Pipfile", "setup.py"].map((f) => (0, import_node_path23.join)(root, f)),
+    ...files.filter((f) => f.includes("/") && /(^|\/)(pyproject\.toml|requirements\.txt)$/.test(f)).slice(0, NESTED_MANIFEST_LIMIT).map((f) => (0, import_node_path23.join)(root, f))
   ];
   for (const path of pythonManifests) {
-    if (!(0, import_node_fs24.existsSync)(path)) continue;
+    if (!(0, import_node_fs25.existsSync)(path)) continue;
     try {
-      const text = (0, import_node_fs24.readFileSync)(path, "utf-8");
+      const text = (0, import_node_fs25.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;
@@ -17723,13 +18028,13 @@ function declaredDependencies(root, files) {
     }
   }
   const goMods = [
-    (0, import_node_path22.join)(root, "go.mod"),
-    ...files.filter((f) => f.includes("/") && (0, import_node_path22.basename)(f) === "go.mod").slice(0, NESTED_MANIFEST_LIMIT).map((f) => (0, import_node_path22.join)(root, f))
+    (0, import_node_path23.join)(root, "go.mod"),
+    ...files.filter((f) => f.includes("/") && (0, import_node_path23.basename)(f) === "go.mod").slice(0, NESTED_MANIFEST_LIMIT).map((f) => (0, import_node_path23.join)(root, f))
   ];
   for (const path of goMods) {
-    if (!(0, import_node_fs24.existsSync)(path)) continue;
+    if (!(0, import_node_fs25.existsSync)(path)) continue;
     try {
-      const text = (0, import_node_fs24.readFileSync)(path, "utf-8");
+      const text = (0, import_node_fs25.readFileSync)(path, "utf-8");
       for (const m of text.matchAll(/^\s+([\w.-]+\/[\w./-]+)\s+v/gm)) {
         names2.push(m[1].replace(/^github\.com\//, ""));
       }
@@ -17737,10 +18042,10 @@ function declaredDependencies(root, files) {
     }
   }
   for (const file of ["pom.xml", "build.gradle", "build.gradle.kts", "Gemfile", "Cargo.toml"]) {
-    const path = (0, import_node_path22.join)(root, file);
-    if (!(0, import_node_fs24.existsSync)(path)) continue;
+    const path = (0, import_node_path23.join)(root, file);
+    if (!(0, import_node_fs25.existsSync)(path)) continue;
     try {
-      const text = (0, import_node_fs24.readFileSync)(path, "utf-8");
+      const text = (0, import_node_fs25.readFileSync)(path, "utf-8");
       for (const m of text.matchAll(/["'<]([A-Za-z][A-Za-z0-9._-]{2,})["'>]/g)) names2.push(m[1]);
     } catch {
     }
@@ -17748,7 +18053,7 @@ function declaredDependencies(root, files) {
   return names2;
 }
 function detectBuildSystem(root, files) {
-  const has = (f) => (0, import_node_fs24.existsSync)((0, import_node_path22.join)(root, f)) || files.some((p) => (0, import_node_path22.basename)(p) === f);
+  const has = (f) => (0, import_node_fs25.existsSync)((0, import_node_path23.join)(root, f)) || files.some((p) => (0, import_node_path23.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";
@@ -17765,8 +18070,8 @@ 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_fs24.existsSync)((0, import_node_path22.join)(root, m)))) return "monorepo";
-  const pkg = readJson((0, import_node_path22.join)(root, "package.json"));
+  if (workspaceMarkers.some((m) => (0, import_node_fs25.existsSync)((0, import_node_path23.join)(root, m)))) return "monorepo";
+  const pkg = readJson((0, import_node_path23.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));
   const nested = manifests.filter((f) => f.includes("/"));
@@ -17788,10 +18093,10 @@ function measureAvgFileLength(root, files, languages) {
   let total = 0;
   let counted = 0;
   for (let i = 0; i < candidates2.length; i += stride) {
-    const path = (0, import_node_path22.join)(root, candidates2[i]);
+    const path = (0, import_node_path23.join)(root, candidates2[i]);
     try {
-      if ((0, import_node_fs24.statSync)(path).size > 2 * 1024 * 1024) continue;
-      total += (0, import_node_fs24.readFileSync)(path, "utf-8").split("\n").length;
+      if ((0, import_node_fs25.statSync)(path).size > 2 * 1024 * 1024) continue;
+      total += (0, import_node_fs25.readFileSync)(path, "utf-8").split("\n").length;
       counted++;
     } catch {
     }
@@ -17821,14 +18126,14 @@ function detectProject(root = repoRoot()) {
   const existingToolConfigs = [];
   for (const [tool, markers] of TOOL_CONFIG_MARKERS) {
     for (const marker of markers) {
-      if ((0, import_node_fs24.existsSync)((0, import_node_path22.join)(root, marker))) {
+      if ((0, import_node_fs25.existsSync)((0, import_node_path23.join)(root, marker))) {
         existingToolConfigs.push({ tool, path: `./${marker}` });
         break;
       }
     }
   }
   return {
-    projectName: (0, import_node_path22.basename)(root),
+    projectName: (0, import_node_path23.basename)(root),
     languages,
     languageCounts,
     frameworks: matchAll(dependencies, FRAMEWORK_BY_DEPENDENCY),
@@ -17926,8 +18231,8 @@ ${closingNote(input.origin)}
 
 // src/lib/synthesize.ts
 function loadCatalog() {
-  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"));
+  const catalog = (0, import_yaml.parse)((0, import_node_fs26.readFileSync)(setupDataPath("patterns-reference.yaml"), "utf-8"));
+  const template = (0, import_yaml.parse)((0, import_node_fs26.readFileSync)(setupDataPath("standard-template.yaml"), "utf-8"));
   return { catalog, template };
 }
 function selectTools(languages, intensity, catalog) {
@@ -18205,7 +18510,7 @@ function validatePatternIds() {
 }
 async function runSynthesis(opts) {
   const standardPath = projectPath(STANDARD_FILE);
-  if ((0, import_node_fs25.existsSync)(standardPath) && !opts.force) {
+  if ((0, import_node_fs26.existsSync)(standardPath) && !opts.force) {
     return { refused: `${STANDARD_FILE} already exists \u2014 pass --force to replace it.` };
   }
   const detected = opts.detected ?? detectProject();
@@ -18274,8 +18579,8 @@ async function correctVerityMdVersion(opts) {
 }
 async function writeFileTo(relative2, body) {
   const target = projectPath(relative2);
-  await (0, import_promises9.mkdir)((0, import_node_path23.dirname)(target), { recursive: true });
-  await (0, import_promises9.writeFile)(target, body);
+  await (0, import_promises10.mkdir)((0, import_node_path24.dirname)(target), { recursive: true });
+  await (0, import_promises10.writeFile)(target, body);
 }
 async function deriveConfigForStandard(standard) {
   const spec = standard.knowledge_spec ?? {};
@@ -18332,14 +18637,14 @@ ${validation.detail}`);
 }
 
 // src/lib/setup-state.ts
-var import_promises10 = require("node:fs/promises");
-var import_node_fs26 = require("node:fs");
+var import_promises11 = require("node:fs/promises");
+var import_node_fs27 = require("node:fs");
 var SETUP_STATE_FILE = `${VERITY_DIR}/setup.json`;
 async function readSetupState() {
   const path = projectPath(SETUP_STATE_FILE);
-  if (!(0, import_node_fs26.existsSync)(path)) return null;
+  if (!(0, import_node_fs27.existsSync)(path)) return null;
   try {
-    const parsed = JSON.parse(await (0, import_promises10.readFile)(path, "utf-8"));
+    const parsed = JSON.parse(await (0, import_promises11.readFile)(path, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : null;
   } catch {
     return null;
@@ -18353,12 +18658,12 @@ async function writeSetupState(patch) {
 }
 
 // src/lib/push-setup.ts
-var import_node_fs28 = require("node:fs");
-var import_promises11 = require("node:fs/promises");
+var import_node_fs29 = require("node:fs");
+var import_promises12 = require("node:fs/promises");
 var import_yaml2 = __toESM(require_dist());
 
 // src/lib/verityignore.ts
-var import_node_fs27 = require("node:fs");
+var import_node_fs28 = require("node:fs");
 var EMPTY = { rules: [], securityOverlap: [], problems: [] };
 var SECURITY_PROBES = [
   ".env",
@@ -18451,9 +18756,9 @@ function isIgnored3(ig, path) {
 }
 function loadVerityIgnore() {
   const file = projectPath(VERITYIGNORE_FILE);
-  if (!(0, import_node_fs27.existsSync)(file)) return EMPTY;
+  if (!(0, import_node_fs28.existsSync)(file)) return EMPTY;
   try {
-    return parseVerityIgnore((0, import_node_fs27.readFileSync)(file, "utf-8"));
+    return parseVerityIgnore((0, import_node_fs28.readFileSync)(file, "utf-8"));
   } catch {
     return EMPTY;
   }
@@ -18491,9 +18796,9 @@ function buildStandardUpload(standard, ignoreRaw) {
 }
 function readVerityIgnoreRaw() {
   const file = projectPath(VERITYIGNORE_FILE);
-  if (!(0, import_node_fs27.existsSync)(file)) return null;
+  if (!(0, import_node_fs28.existsSync)(file)) return null;
   try {
-    return (0, import_node_fs27.readFileSync)(file, "utf-8");
+    return (0, import_node_fs28.readFileSync)(file, "utf-8");
   } catch {
     return null;
   }
@@ -18521,9 +18826,9 @@ async function pushStandardAndConfig(globals, what = {}) {
   }
   let standardVersion = null;
   const standardPath = projectPath(STANDARD_FILE);
-  if (pushStandard && (0, import_node_fs28.existsSync)(standardPath)) {
+  if (pushStandard && (0, import_node_fs29.existsSync)(standardPath)) {
     try {
-      const content = (0, import_yaml2.parse)(await (0, import_promises11.readFile)(standardPath, "utf-8"));
+      const content = (0, import_yaml2.parse)(await (0, import_promises12.readFile)(standardPath, "utf-8"));
       const upload = buildStandardUpload(content, readVerityIgnoreRaw());
       if (upload.warning) lines.push(upload.warning);
       const result = await apiRequest({
@@ -18546,9 +18851,9 @@ async function pushStandardAndConfig(globals, what = {}) {
   }
   let configPushed = false;
   const configPath = projectPath(CODACY_CONFIG_FILE);
-  if (pushConfig && (0, import_node_fs28.existsSync)(configPath)) {
+  if (pushConfig && (0, import_node_fs29.existsSync)(configPath)) {
     try {
-      const content = JSON.parse(await (0, import_promises11.readFile)(configPath, "utf-8"));
+      const content = JSON.parse(await (0, import_promises12.readFile)(configPath, "utf-8"));
       const result = await apiRequest({
         method: "POST",
         path: "/analysis-configs",
@@ -18578,11 +18883,11 @@ function registerStandardCommands(program2) {
     const state = await readSetupState();
     if (opts.configOnly) {
       const standardPath = projectPath(STANDARD_FILE);
-      if (!(0, import_node_fs29.existsSync)(standardPath)) {
+      if (!(0, import_node_fs30.existsSync)(standardPath)) {
         printError(`No ${STANDARD_FILE} here \u2014 run "verity standard synthesize" to create one.`);
         process.exit(1);
       }
-      const content = (0, import_yaml3.parse)(await (0, import_promises12.readFile)(standardPath, "utf-8"));
+      const content = (0, import_yaml3.parse)(await (0, import_promises13.readFile)(standardPath, "utf-8"));
       const derived = await deriveConfigForStandard(content);
       for (const path of derived.written) printInfo(`  ${path} \u2713`);
       for (const note of derived.notes) printWarn(`  ${note}`);
@@ -18638,7 +18943,7 @@ function registerStandardCommands(program2) {
     }
     let yamlContent;
     try {
-      yamlContent = await (0, import_promises12.readFile)(opts.file, "utf-8");
+      yamlContent = await (0, import_promises13.readFile)(opts.file, "utf-8");
     } catch {
       printError(`Cannot read ${opts.file}`);
       process.exit(1);
@@ -18735,7 +19040,7 @@ function parseIntensity(value) {
 }
 
 // src/commands/config.ts
-var import_promises13 = require("node:fs/promises");
+var import_promises14 = require("node:fs/promises");
 function registerConfigCommands(program2) {
   const config = program2.command("config").description("Manage analysis configuration");
   config.command("service-url").description("Print the resolved service URL (used by the shipped skills)").action(async () => {
@@ -18781,7 +19086,7 @@ function registerConfigCommands(program2) {
     }
     let content;
     try {
-      const raw = await (0, import_promises13.readFile)(opts.file, "utf-8");
+      const raw = await (0, import_promises14.readFile)(opts.file, "utf-8");
       content = JSON.parse(raw);
     } catch {
       printError(`Cannot read or parse ${opts.file}`);
@@ -18909,10 +19214,10 @@ function formatRunDetail(run2) {
 }
 
 // src/lib/ignore-declaration.ts
-var import_node_fs31 = require("node:fs");
+var import_node_fs32 = require("node:fs");
 
 // src/lib/debounce.ts
-var import_node_fs30 = require("node:fs");
+var import_node_fs31 = require("node:fs");
 var import_node_crypto10 = require("node:crypto");
 function scopedFile(base, sessionId) {
   if (!sessionId) return base;
@@ -18920,9 +19225,9 @@ function scopedFile(base, sessionId) {
 }
 function checkDebounce(debounceSeconds = DEBOUNCE_SECONDS, sessionId) {
   const file = scopedFile(DEBOUNCE_FILE, sessionId);
-  if (!(0, import_node_fs30.existsSync)(file)) return null;
+  if (!(0, import_node_fs31.existsSync)(file)) return null;
   try {
-    const lastTs = parseInt((0, import_node_fs30.readFileSync)(file, "utf-8").trim(), 10);
+    const lastTs = parseInt((0, import_node_fs31.readFileSync)(file, "utf-8").trim(), 10);
     const nowTs = Math.floor(Date.now() / 1e3);
     const elapsed = nowTs - lastTs;
     if (elapsed < debounceSeconds) {
@@ -18935,10 +19240,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_fs30.existsSync)(file)) return null;
+  if (!(0, import_node_fs31.existsSync)(file)) return null;
   let debounceTime;
   try {
-    debounceTime = (0, import_node_fs30.statSync)(file).mtimeMs;
+    debounceTime = (0, import_node_fs31.statSync)(file).mtimeMs;
   } catch {
     return null;
   }
@@ -18946,7 +19251,7 @@ function checkMtime(files, bypassForRecentCommits, sessionId) {
     const resolved = resolveFile(f);
     if (!resolved) continue;
     try {
-      const stat3 = (0, import_node_fs30.statSync)(resolved);
+      const stat3 = (0, import_node_fs31.statSync)(resolved);
       if (stat3.mtimeMs > debounceTime) {
         return null;
       }
@@ -18962,8 +19267,8 @@ function computeContentHash(files) {
   for (const f of sorted) {
     const resolved = resolveFile(f) ?? f;
     try {
-      if ((0, import_node_fs30.existsSync)(resolved)) {
-        hash.update((0, import_node_fs30.readFileSync)(resolved));
+      if ((0, import_node_fs31.existsSync)(resolved)) {
+        hash.update((0, import_node_fs31.readFileSync)(resolved));
       }
     } catch {
     }
@@ -18973,9 +19278,9 @@ function computeContentHash(files) {
 function checkContentHash(files, sessionId) {
   const hash = computeContentHash(files);
   const file = scopedFile(HASH_FILE, sessionId);
-  if ((0, import_node_fs30.existsSync)(file)) {
+  if ((0, import_node_fs31.existsSync)(file)) {
     try {
-      const storedHash = (0, import_node_fs30.readFileSync)(file, "utf-8").trim();
+      const storedHash = (0, import_node_fs31.readFileSync)(file, "utf-8").trim();
       if (hash === storedHash) {
         return { skip: "No source changes since last analysis", hash };
       }
@@ -18985,24 +19290,24 @@ function checkContentHash(files, sessionId) {
   return { skip: null, hash };
 }
 function recordAnalysisStart(sessionId) {
-  (0, import_node_fs30.mkdirSync)(VERITY_DIR, { recursive: true });
-  (0, import_node_fs30.writeFileSync)(scopedFile(DEBOUNCE_FILE, sessionId), String(Math.floor(Date.now() / 1e3)));
+  (0, import_node_fs31.mkdirSync)(VERITY_DIR, { recursive: true });
+  (0, import_node_fs31.writeFileSync)(scopedFile(DEBOUNCE_FILE, sessionId), String(Math.floor(Date.now() / 1e3)));
 }
 function recordPassHash(hash, sessionId) {
-  (0, import_node_fs30.writeFileSync)(scopedFile(HASH_FILE, sessionId), hash);
+  (0, import_node_fs31.writeFileSync)(scopedFile(HASH_FILE, sessionId), hash);
 }
 function narrowToRecent(files, sessionId) {
   const file = scopedFile(DEBOUNCE_FILE, sessionId);
-  if (!(0, import_node_fs30.existsSync)(file)) return files;
+  if (!(0, import_node_fs31.existsSync)(file)) return files;
   let debounceTime;
   try {
-    debounceTime = (0, import_node_fs30.statSync)(file).mtimeMs;
+    debounceTime = (0, import_node_fs31.statSync)(file).mtimeMs;
   } catch {
     return files;
   }
   const recent = files.filter((f) => {
     try {
-      return (0, import_node_fs30.existsSync)(f) && (0, import_node_fs30.statSync)(f).mtimeMs > debounceTime;
+      return (0, import_node_fs31.existsSync)(f) && (0, import_node_fs31.statSync)(f).mtimeMs > debounceTime;
     } catch {
       return false;
     }
@@ -19015,9 +19320,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_fs30.existsSync)(ITERATION_FILE)) return NO_BLOCKS;
+  if (!(0, import_node_fs31.existsSync)(ITERATION_FILE)) return NO_BLOCKS;
   try {
-    const stored = (0, import_node_fs30.readFileSync)(ITERATION_FILE, "utf-8").trim();
+    const stored = (0, import_node_fs31.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;
@@ -19063,8 +19368,8 @@ function isSameProblem(previous, current) {
   return current.split(",").some((k) => prev.has(k));
 }
 function writeBlockState(commit, state) {
-  (0, import_node_fs30.mkdirSync)(VERITY_DIR, { recursive: true });
-  (0, import_node_fs30.writeFileSync)(
+  (0, import_node_fs31.mkdirSync)(VERITY_DIR, { recursive: true });
+  (0, import_node_fs31.writeFileSync)(
     ITERATION_FILE,
     JSON.stringify({
       v: 2,
@@ -19169,9 +19474,9 @@ function resolveIgnoreState(keys) {
 }
 function readIgnoreState(sessionId) {
   const file = stateFile(sessionId);
-  if (!(0, import_node_fs31.existsSync)(file)) return null;
+  if (!(0, import_node_fs32.existsSync)(file)) return null;
   try {
-    const o = JSON.parse((0, import_node_fs31.readFileSync)(file, "utf-8")) ?? {};
+    const o = JSON.parse((0, import_node_fs32.readFileSync)(file, "utf-8")) ?? {};
     const spent = typeof o.spent === "number" ? o.spent : 0;
     const raw = o.active;
     let active = null;
@@ -19195,8 +19500,8 @@ function readIgnoreState(sessionId) {
 }
 function writeIgnoreState(state, sessionId) {
   try {
-    (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 }));
+    (0, import_node_fs32.mkdirSync)(projectPath(VERITY_DIR), { recursive: true });
+    (0, import_node_fs32.writeFileSync)(stateFile(sessionId), JSON.stringify({ v: 1, active: state.active, spent: state.spent }));
   } catch {
   }
 }
@@ -19579,7 +19884,7 @@ function createRun(opts, globals) {
 }
 
 // src/commands/analyze/index.ts
-var import_node_fs44 = require("node:fs");
+var import_node_fs45 = require("node:fs");
 
 // src/lib/repo-context.ts
 var import_node_child_process10 = require("node:child_process");
@@ -20407,10 +20712,10 @@ function installRunEvidence(run2) {
 }
 
 // src/lib/git-frame.ts
-var import_node_fs32 = require("node:fs");
+var import_node_fs33 = require("node:fs");
 var import_node_os5 = require("node:os");
-var import_node_path24 = require("node:path");
 var import_node_path25 = require("node:path");
+var import_node_path26 = require("node:path");
 
 // src/lib/hardened-git.ts
 var import_node_child_process11 = require("node:child_process");
@@ -20572,8 +20877,8 @@ function extractCommandTarget(command, segmentIndex, baseDir) {
     if (SHELL_DYNAMIC.test(raw) || raw === "-") {
       return { dir: null, named: true, unresolvable: `cd target not statically resolvable: ${raw}` };
     }
-    const expanded = raw === "~" ? (0, import_node_os5.homedir)() : raw.startsWith("~/") ? (0, import_node_path25.join)((0, import_node_os5.homedir)(), raw.slice(2)) : raw;
-    dir = (0, import_node_path24.isAbsolute)(expanded) ? expanded : (0, import_node_path24.resolve)(dir, expanded);
+    const expanded = raw === "~" ? (0, import_node_os5.homedir)() : raw.startsWith("~/") ? (0, import_node_path26.join)((0, import_node_os5.homedir)(), raw.slice(2)) : raw;
+    dir = (0, import_node_path25.isAbsolute)(expanded) ? expanded : (0, import_node_path25.resolve)(dir, expanded);
   }
   const seg = segments[segmentIndex];
   const overrideMatch = /--(?:git-dir|work-tree)(?:=|\s)|\bGIT_(?:DIR|WORK_TREE|INDEX_FILE)=/.exec(seg);
@@ -20591,8 +20896,8 @@ function extractCommandTarget(command, segmentIndex, baseDir) {
       if (SHELL_DYNAMIC.test(raw)) {
         return { dir: null, named: true, unresolvable: `-C target not statically resolvable: ${raw}` };
       }
-      const expanded = raw === "~" ? (0, import_node_os5.homedir)() : raw.startsWith("~/") ? (0, import_node_path25.join)((0, import_node_os5.homedir)(), raw.slice(2)) : raw;
-      dir = (0, import_node_path24.isAbsolute)(expanded) ? expanded : (0, import_node_path24.resolve)(dir, expanded);
+      const expanded = raw === "~" ? (0, import_node_os5.homedir)() : raw.startsWith("~/") ? (0, import_node_path26.join)((0, import_node_os5.homedir)(), raw.slice(2)) : raw;
+      dir = (0, import_node_path25.isAbsolute)(expanded) ? expanded : (0, import_node_path25.resolve)(dir, expanded);
     }
   }
   return { dir, named, unresolvable: null };
@@ -20652,14 +20957,14 @@ function gitAt(dir, args) {
 }
 function realpathOr2(p) {
   try {
-    return import_node_fs32.realpathSync.native(p);
+    return import_node_fs33.realpathSync.native(p);
   } catch {
-    return (0, import_node_path24.resolve)(p);
+    return (0, import_node_path25.resolve)(p);
   }
 }
 function resolveFrame(input) {
   const found = findMomentSegment(input.command, input.on);
-  const hookDirUsable = !!input.hookCwd && (0, import_node_fs32.existsSync)(input.hookCwd);
+  const hookDirUsable = !!input.hookCwd && (0, import_node_fs33.existsSync)(input.hookCwd);
   const baseDir = hookDirUsable ? input.hookCwd : process.cwd();
   let anchor = hookDirUsable ? "hook-cwd" : "process-cwd";
   const refuse = (refusal) => ({
@@ -20682,7 +20987,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_fs32.existsSync)(targetDir)) return refuse(`target:directory does not exist: ${targetDir}`);
+      if (!(0, import_node_fs33.existsSync)(targetDir)) return refuse(`target:directory does not exist: ${targetDir}`);
       dir = targetDir;
     }
   }
@@ -20693,7 +20998,7 @@ function resolveFrame(input) {
   const gitDirRaw = gitAt(dir, ["rev-parse", "--absolute-git-dir"]);
   const commonRaw = gitAt(dir, ["rev-parse", "--git-common-dir"]);
   const gitDir = gitDirRaw ? realpathOr2(gitDirRaw) : null;
-  const commonDir = commonRaw ? realpathOr2((0, import_node_path24.isAbsolute)(commonRaw) ? commonRaw : (0, import_node_path24.resolve)(dir, commonRaw)) : null;
+  const commonDir = commonRaw ? realpathOr2((0, import_node_path25.isAbsolute)(commonRaw) ? commonRaw : (0, import_node_path25.resolve)(dir, commonRaw)) : null;
   const branchRaw = gitAt(dir, ["rev-parse", "--abbrev-ref", "HEAD"]);
   return {
     moment: found?.moment ?? null,
@@ -20868,8 +21173,8 @@ function stagedRange(frame, command) {
   if (plan.kind === "unpredictable") {
     return { kind: "staged", base: "HEAD", head: "INDEX", via: "staged-in-command", refusal: plan.reason };
   }
-  const mergeHead = frame.gitDir ? (0, import_node_path25.join)(frame.gitDir, "MERGE_HEAD") : null;
-  if (mergeHead && (0, import_node_fs32.existsSync)(mergeHead)) {
+  const mergeHead = frame.gitDir ? (0, import_node_path26.join)(frame.gitDir, "MERGE_HEAD") : null;
+  if (mergeHead && (0, import_node_fs33.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)));
@@ -21003,7 +21308,7 @@ function truthy(v) {
 }
 
 // src/lib/transcript.ts
-var import_node_fs33 = require("node:fs");
+var import_node_fs34 = require("node:fs");
 var MAX_READ_BYTES = 256 * 1024;
 var SMALL_FILE_BYTES = 64 * 1024;
 var MAX_FILES_LIST = 20;
@@ -21030,7 +21335,7 @@ async function extractActionSummary(transcriptPath) {
 function readTurnLines(transcriptPath) {
   let size;
   try {
-    size = (0, import_node_fs33.statSync)(transcriptPath).size;
+    size = (0, import_node_fs34.statSync)(transcriptPath).size;
   } catch {
     return null;
   }
@@ -21038,7 +21343,7 @@ function readTurnLines(transcriptPath) {
   let raw;
   let windowed = false;
   if (size <= SMALL_FILE_BYTES) {
-    raw = (0, import_node_fs33.readFileSync)(transcriptPath, "utf-8");
+    raw = (0, import_node_fs34.readFileSync)(transcriptPath, "utf-8");
   } else {
     windowed = true;
     const buf = Buffer.alloc(Math.min(MAX_READ_BYTES, size));
@@ -21546,7 +21851,7 @@ function channelSilence(input) {
 // src/lib/cli-version.ts
 function cliVersion() {
   try {
-    return true ? "0.32.6-experimental.8f2b5f7" : "dev";
+    return true ? "0.32.6-experimental.df0a578" : "dev";
   } catch {
     return "dev";
   }
@@ -21587,7 +21892,7 @@ async function sendSkipBeacon(ctx, reason) {
 
 // src/lib/static-analysis.ts
 var import_node_child_process12 = require("node:child_process");
-var import_node_fs34 = require("node:fs");
+var import_node_fs35 = require("node:fs");
 var SEVERITY_ORDER = {
   Error: 0,
   Critical: 0,
@@ -21635,7 +21940,7 @@ function runCodacyAnalysis(files) {
   if (files.length === 0) return empty;
   const existingFiles = files.filter((f) => {
     try {
-      return (0, import_node_fs34.existsSync)(f);
+      return (0, import_node_fs35.existsSync)(f);
     } catch {
       return false;
     }
@@ -21904,8 +22209,8 @@ async function scope(run2) {
 }
 
 // src/lib/specs.ts
-var import_node_fs35 = require("node:fs");
-var import_node_path26 = require("node:path");
+var import_node_fs36 = require("node:fs");
+var import_node_path27 = require("node:path");
 var SPEC_CANDIDATES = [
   "CLAUDE.md",
   "AGENTS.md",
@@ -21936,7 +22241,7 @@ 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_fs35.existsSync)(specPath)) return true;
+    if (!(0, import_node_fs36.existsSync)(specPath)) return true;
     seen.add(specPath);
     const remaining = totalCap - totalBytes;
     const fileCap = relevant ? MAX_SPEC_FILE_BYTES : UNCONSULTED_FILE_BYTES;
@@ -21959,7 +22264,7 @@ function discoverSpecs(consulted = []) {
     if (!addSpec(candidate)) break;
   }
   for (const dir of ["spec", "docs"]) {
-    if (!(0, import_node_fs35.existsSync)(dir)) continue;
+    if (!(0, import_node_fs36.existsSync)(dir)) continue;
     try {
       const mdFiles = findMdFiles(dir, 2).sort();
       for (const mdFile of mdFiles) {
@@ -21974,9 +22279,9 @@ function findMdFiles(dir, maxDepth, depth = 0) {
   if (depth >= maxDepth) return [];
   const result = [];
   try {
-    const entries = (0, import_node_fs35.readdirSync)(dir, { withFileTypes: true });
+    const entries = (0, import_node_fs36.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = (0, import_node_path26.join)(dir, entry.name);
+      const fullPath = (0, import_node_path27.join)(dir, entry.name);
       if (entry.isFile() && entry.name.endsWith(".md")) {
         result.push(fullPath);
       } else if (entry.isDirectory() && depth < maxDepth - 1) {
@@ -21989,25 +22294,25 @@ function findMdFiles(dir, maxDepth, depth = 0) {
 }
 function discoverPlans() {
   const home = process.env.HOME ?? "";
-  const homePlansDir = (0, import_node_path26.join)(home, ".claude", "plans");
+  const homePlansDir = (0, import_node_path27.join)(home, ".claude", "plans");
   const sources = [];
   if (isRealDirectoryChain(process.cwd(), [".claude", "plans"])) {
-    sources.push({ root: process.cwd(), prefix: (0, import_node_path26.join)(".claude", "plans") });
+    sources.push({ root: process.cwd(), prefix: (0, import_node_path27.join)(".claude", "plans") });
   }
-  if (home && (0, import_node_fs35.existsSync)(homePlansDir)) sources.push({ root: homePlansDir, prefix: "" });
+  if (home && (0, import_node_fs36.existsSync)(homePlansDir)) sources.push({ root: homePlansDir, prefix: "" });
   const candidates2 = [];
   const seen = /* @__PURE__ */ new Set();
   for (const source of sources) {
     let names2;
     try {
-      names2 = (0, import_node_fs35.readdirSync)(source.prefix ? (0, import_node_path26.join)(source.root, source.prefix) : source.root);
+      names2 = (0, import_node_fs36.readdirSync)(source.prefix ? (0, import_node_path27.join)(source.root, source.prefix) : source.root);
     } catch {
       continue;
     }
     for (const f of names2) {
       if (!f.endsWith(".md") || seen.has(f)) continue;
       seen.add(f);
-      const relPath = source.prefix ? (0, import_node_path26.join)(source.prefix, f) : f;
+      const relPath = source.prefix ? (0, import_node_path27.join)(source.prefix, f) : f;
       const stat3 = statRegularInRoot(source.root, relPath);
       if (!stat3.ok) continue;
       candidates2.push({ name: f, root: source.root, relPath, mtime: stat3.mtimeMs, size: stat3.size });
@@ -22025,9 +22330,9 @@ function discoverPlans() {
 function isRealDirectoryChain(root, parts) {
   let current = root;
   for (const part of parts) {
-    current = (0, import_node_path26.join)(current, part);
+    current = (0, import_node_path27.join)(current, part);
     try {
-      if (!(0, import_node_fs35.lstatSync)(current).isDirectory()) return false;
+      if (!(0, import_node_fs36.lstatSync)(current).isDirectory()) return false;
     } catch {
       return false;
     }
@@ -22042,7 +22347,7 @@ 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_fs35.existsSync)(path)) continue;
+    if (!(0, import_node_fs36.existsSync)(path)) continue;
     const opened = openRegularInRoot(process.cwd(), path);
     if (!opened.ok) continue;
     if (opened.size > MAX_PLAN_FILE_BYTES || totalBytes + opened.size > MAX_TOTAL_SPEC_BYTES) {
@@ -22228,8 +22533,8 @@ async function mode(run2) {
 }
 
 // src/lib/fold.ts
-var import_node_fs36 = require("node:fs");
-var import_node_path27 = require("node:path");
+var import_node_fs37 = require("node:fs");
+var import_node_path28 = require("node:path");
 var KNOWN_RECORD_TYPES = /* @__PURE__ */ new Set([
   "user",
   "assistant",
@@ -22366,7 +22671,7 @@ function candidateRoots(repoRoot2) {
   const norm = repoRoot2.replace(/\\/g, "/").replace(/\/+$/, "");
   const out = [norm];
   try {
-    const real = import_node_fs36.realpathSync.native(norm).replace(/\\/g, "/").replace(/\/+$/, "");
+    const real = import_node_fs37.realpathSync.native(norm).replace(/\\/g, "/").replace(/\/+$/, "");
     if (real !== norm) out.push(real);
   } catch {
   }
@@ -22454,31 +22759,31 @@ function fold(transcriptPath, opts = {}) {
     }
   };
   try {
-    if (!(0, import_node_fs36.existsSync)(transcriptPath)) return result;
-    ingest((0, import_node_fs36.readFileSync)(transcriptPath, "utf8"), "agent");
+    if (!(0, import_node_fs37.existsSync)(transcriptPath)) return result;
+    ingest((0, import_node_fs37.readFileSync)(transcriptPath, "utf8"), "agent");
     result.coverage.complete = true;
   } catch {
     return result;
   }
   try {
-    const sidecarDir = (0, import_node_path27.join)(
-      (0, import_node_path27.dirname)(transcriptPath),
-      (0, import_node_path27.basename)(transcriptPath).replace(/\.jsonl$/, ""),
+    const sidecarDir = (0, import_node_path28.join)(
+      (0, import_node_path28.dirname)(transcriptPath),
+      (0, import_node_path28.basename)(transcriptPath).replace(/\.jsonl$/, ""),
       "subagents"
     );
-    if ((0, import_node_fs36.existsSync)(sidecarDir)) {
+    if ((0, import_node_fs37.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_fs36.readdirSync)(d, { withFileTypes: true })) {
-          const p = (0, import_node_path27.join)(d, e.name);
+        for (const e of (0, import_node_fs37.readdirSync)(d, { withFileTypes: true })) {
+          const p = (0, import_node_path28.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_fs36.statSync)(p);
+              const st = (0, import_node_fs37.statSync)(p);
               found.push({ path: p, size: st.size, mtimeMs: st.mtimeMs });
             } catch {
               result.coverage.malformed++;
@@ -22495,7 +22800,7 @@ function fold(transcriptPath, opts = {}) {
           continue;
         }
         try {
-          ingest((0, import_node_fs36.readFileSync)(f.path, "utf8"), "subagent");
+          ingest((0, import_node_fs37.readFileSync)(f.path, "utf8"), "subagent");
           bytes += f.size;
           result.coverage.subagentFiles++;
         } catch {
@@ -22530,7 +22835,7 @@ function fold(transcriptPath, opts = {}) {
 }
 function classifyUnobserved(path) {
   try {
-    const st = (0, import_node_fs36.statSync)(path);
+    const st = (0, import_node_fs37.statSync)(path);
     if (!st.isFile()) return "unreadable";
   } catch {
     return "unreadable";
@@ -22847,20 +23152,20 @@ async function evidence(run2) {
 }
 
 // src/lib/cache-cleanup.ts
-var import_node_fs37 = require("node:fs");
-var import_node_path28 = require("node:path");
+var import_node_fs38 = require("node:fs");
+var import_node_path29 = 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_fs37.readdirSync)(dir)) {
+    for (const entry of (0, import_node_fs38.readdirSync)(dir)) {
       if (!entry.startsWith("pending-")) continue;
-      const path = (0, import_node_path28.join)(dir, entry);
+      const path = (0, import_node_path29.join)(dir, entry);
       try {
-        const stat3 = (0, import_node_fs37.statSync)(path);
+        const stat3 = (0, import_node_fs38.statSync)(path);
         if (stat3.mtimeMs < cutoff) {
-          (0, import_node_fs37.unlinkSync)(path);
+          (0, import_node_fs38.unlinkSync)(path);
           logEvent("cache_entry_pruned", {
             path: entry,
             age_days: Math.round((Date.now() - stat3.mtimeMs) / 864e5)
@@ -22874,7 +23179,7 @@ function pruneStaleCache() {
 }
 
 // src/lib/context-files.ts
-var import_node_fs38 = require("node:fs");
+var import_node_fs39 = require("node:fs");
 var import_node_os6 = require("node:os");
 var MAX_CONTEXT_FILES = 10;
 var MAX_CONTEXT_FILE_BYTES = 10240;
@@ -22932,7 +23237,7 @@ function gatherContextFiles(contextPaths, deltaFiles, opts) {
       continue;
     }
     try {
-      const content = (0, import_node_fs38.readFileSync)(safePath, "utf8");
+      const content = (0, import_node_fs39.readFileSync)(safePath, "utf8");
       const bytes = Buffer.byteLength(content);
       if (bytes > MAX_CONTEXT_FILE_BYTES) {
         logEvent("context_file_skipped", { path: filePath, reason: "too_large", bytes });
@@ -23022,9 +23327,9 @@ async function repoContext(run2) {
 }
 
 // src/lib/seed-runner.ts
-var import_promises14 = require("node:fs/promises");
-var import_node_fs39 = require("node:fs");
-var import_node_path29 = require("node:path");
+var import_promises15 = require("node:fs/promises");
+var import_node_fs40 = require("node:fs");
+var import_node_path30 = require("node:path");
 var import_yaml4 = __toESM(require_dist());
 
 // src/lib/seed.ts
@@ -23100,7 +23405,7 @@ function classifyClaudeSection(heading) {
   if (hasAny(["integration", "webhook", "third-party", "third party", "provider"])) return "integration";
   return "domain";
 }
-function slugify(s) {
+function slugify2(s) {
   return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
 }
 var FRAMEWORK_GLOBS = [
@@ -23197,7 +23502,7 @@ _Extracted from README on setup. Update when project direction changes._`,
   for (const fwRaw of frameworks) {
     const fw = fwRaw.trim();
     if (!fw) continue;
-    const slug = slugify(fw);
+    const slug = slugify2(fw);
     if (!slug || seenFrameworkSlugs.has(slug)) continue;
     seenFrameworkSlugs.add(slug);
     out.push({
@@ -23263,29 +23568,29 @@ function renderNodeMarkdown(candidate, nodeId, createdAt) {
   return fm;
 }
 async function runSeed(opts) {
-  if (!(0, import_node_fs39.existsSync)(STANDARD_FILE)) {
+  if (!(0, import_node_fs40.existsSync)(STANDARD_FILE)) {
     return { created: 0, failed: 0, skipped: "no_standard", candidates: [] };
   }
   let standardDoc;
   try {
-    const raw = await (0, import_promises14.readFile)(STANDARD_FILE, "utf-8");
+    const raw = await (0, import_promises15.readFile)(STANDARD_FILE, "utf-8");
     standardDoc = (0, import_yaml4.parse)(raw);
   } catch {
     return { created: 0, failed: 0, skipped: "no_standard", candidates: [] };
   }
   const knowledgeSpec = standardDoc.knowledge_spec ?? {};
   let readmeContent;
-  if ((0, import_node_fs39.existsSync)("README.md")) {
+  if ((0, import_node_fs40.existsSync)("README.md")) {
     try {
-      readmeContent = await (0, import_promises14.readFile)("README.md", "utf-8");
+      readmeContent = await (0, import_promises15.readFile)("README.md", "utf-8");
     } catch {
     }
   }
   let claudeMdContent;
   for (const p of ["CLAUDE.md", ".claude/CLAUDE.md"]) {
-    if ((0, import_node_fs39.existsSync)(p)) {
+    if ((0, import_node_fs40.existsSync)(p)) {
       try {
-        claudeMdContent = await (0, import_promises14.readFile)(p, "utf-8");
+        claudeMdContent = await (0, import_promises15.readFile)(p, "utf-8");
         break;
       } catch {
       }
@@ -23306,8 +23611,8 @@ async function runSeed(opts) {
   if (candidates2.length === 0) {
     return { created: 0, failed: 0, skipped: "no_candidates", candidates: [] };
   }
-  const overviewPath = (0, import_node_path29.join)(MEMORY_DIR, "domain", "project-overview.md");
-  if ((0, import_node_fs39.existsSync)(overviewPath) && !opts.force) {
+  const overviewPath = (0, import_node_path30.join)(MEMORY_DIR, "domain", "project-overview.md");
+  if ((0, import_node_fs40.existsSync)(overviewPath) && !opts.force) {
     return { created: 0, failed: 0, skipped: "already_seeded", candidates: candidates2 };
   }
   if (opts.dryRun) {
@@ -23349,8 +23654,8 @@ async function runSeed(opts) {
       continue;
     }
     try {
-      await (0, import_promises14.mkdir)((0, import_node_path29.dirname)(targetPath), { recursive: true });
-      await (0, import_promises14.writeFile)(targetPath, renderNodeMarkdown(c, nodeId, createdAt));
+      await (0, import_promises15.mkdir)((0, import_node_path30.dirname)(targetPath), { recursive: true });
+      await (0, import_promises15.writeFile)(targetPath, renderNodeMarkdown(c, nodeId, createdAt));
       created++;
       opts.onCreated?.(nodeId, filePathRel, c);
     } catch (err) {
@@ -23362,8 +23667,8 @@ async function runSeed(opts) {
 }
 
 // src/commands/analyze/phases/08-memory-manifest.ts
-var import_node_fs40 = require("node:fs");
-var import_node_path30 = require("node:path");
+var import_node_fs41 = require("node:fs");
+var import_node_path31 = require("node:path");
 async function memoryManifest(run2) {
   const { globals } = run2;
   const { serviceUrl, token } = run2;
@@ -23373,9 +23678,9 @@ async function memoryManifest(run2) {
   let autoSeedNotice = null;
   try {
     await ensureMemoryDir();
-    const seedMarker = (0, import_node_path30.join)(VERITY_DIR, ".seeded");
-    const hasStandard = (0, import_node_fs40.existsSync)(STANDARD_FILE);
-    const alreadyTried = (0, import_node_fs40.existsSync)(seedMarker);
+    const seedMarker = (0, import_node_path31.join)(VERITY_DIR, ".seeded");
+    const hasStandard = (0, import_node_fs41.existsSync)(STANDARD_FILE);
+    const alreadyTried = (0, import_node_fs41.existsSync)(seedMarker);
     if (hasStandard && !alreadyTried) {
       const preManifest = await buildManifest();
       if (preManifest.nodes.length === 0) {
@@ -23388,7 +23693,7 @@ async function memoryManifest(run2) {
             dryRun: false
           });
           if (seedResult.created > 0) {
-            (0, import_node_fs40.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} created=${seedResult.created}
+            (0, import_node_fs41.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", {
@@ -23396,7 +23701,7 @@ async function memoryManifest(run2) {
               failed: seedResult.failed
             });
           } else if (seedResult.skipped === "already_seeded") {
-            (0, import_node_fs40.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} skipped=already_seeded
+            (0, import_node_fs41.writeFileSync)(seedMarker, `${(/* @__PURE__ */ new Date()).toISOString()} skipped=already_seeded
 `);
           } else {
             logEvent("auto_seed_noop", {
@@ -23491,7 +23796,7 @@ function computeIncrement(reviewedPaths, hashOf, priorAuthored) {
 }
 
 // src/commands/analyze/phases/10-working-memory.ts
-var import_node_path31 = require("node:path");
+var import_node_path32 = require("node:path");
 async function workingMemory(run2) {
   const { opts } = run2;
   const { allForReview, baseline, conversation, foldResult, sessionId, token, transcriptPath } = run2;
@@ -23503,7 +23808,7 @@ async function workingMemory(run2) {
     const priorState = foldForMarks(memorySession.d);
     incrementReport = computeIncrement(
       allForReview,
-      (p) => fileHash((0, import_node_path31.join)(repoRoot(), p)),
+      (p) => fileHash((0, import_node_path32.join)(repoRoot(), p)),
       priorState.authored_all.map((a) => ({
         path: a.path,
         hash_at_last_verdict: a.hash_at_last_verdict
@@ -23585,7 +23890,7 @@ async function workingMemory(run2) {
 }
 
 // src/lib/note-budget.ts
-var import_node_fs41 = require("node:fs");
+var import_node_fs42 = require("node:fs");
 var ADVISORY_BUDGET = { PASS: 1, WARN: 2 };
 var EPISODE_STALE_SECONDS = 30 * 60;
 var FRESH = { delivered: 0, tasksCompleted: 0, ts: 0 };
@@ -23607,9 +23912,9 @@ function advisoryBudgetSpent(episode, rawDecision) {
 }
 function readAdvisoryEpisode(sessionId) {
   const file = scopedFile(ADVISORY_EPISODE_FILE, sessionId);
-  if (!(0, import_node_fs41.existsSync)(file)) return null;
+  if (!(0, import_node_fs42.existsSync)(file)) return null;
   try {
-    const o = JSON.parse((0, import_node_fs41.readFileSync)(file, "utf-8")) ?? {};
+    const o = JSON.parse((0, import_node_fs42.readFileSync)(file, "utf-8")) ?? {};
     const delivered = typeof o.delivered === "number" ? o.delivered : NaN;
     if (isNaN(delivered)) return null;
     return {
@@ -23623,8 +23928,8 @@ function readAdvisoryEpisode(sessionId) {
 }
 function writeAdvisoryEpisode(episode, sessionId) {
   try {
-    (0, import_node_fs41.mkdirSync)(VERITY_DIR, { recursive: true });
-    (0, import_node_fs41.writeFileSync)(
+    (0, import_node_fs42.mkdirSync)(VERITY_DIR, { recursive: true });
+    (0, import_node_fs42.writeFileSync)(
       scopedFile(ADVISORY_EPISODE_FILE, sessionId),
       JSON.stringify({ v: 1, ...episode })
     );
@@ -23932,14 +24237,14 @@ async function buildRequest(run2) {
 }
 
 // src/lib/offline.ts
-var import_node_fs42 = require("node:fs");
+var import_node_fs43 = require("node:fs");
 var import_node_crypto11 = require("node:crypto");
 function cacheRequest(body) {
   try {
-    (0, import_node_fs42.mkdirSync)(CACHE_DIR, { recursive: true });
+    (0, import_node_fs43.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_fs42.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(redactRequest(body)));
+    (0, import_node_fs43.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(redactRequest(body)));
   } catch {
   }
 }
@@ -24058,8 +24363,8 @@ async function transmit(run2) {
 }
 
 // src/commands/analyze/phases/13-reconcile.ts
-var import_node_fs43 = require("node:fs");
-var import_node_path32 = require("node:path");
+var import_node_fs44 = require("node:fs");
+var import_node_path33 = 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;
   const sentPaths = codeDelta.files.map((f) => f.path);
@@ -24088,7 +24393,7 @@ async function reconcile(run2) {
       const st = foldDossier(memorySession.d);
       openElsewhere = openBlockingElsewhere(st.statements, sentPaths, (file, line) => {
         try {
-          const src = (0, import_node_fs43.readFileSync)((0, import_node_path32.join)(repoRoot(), file), "utf8").split("\n");
+          const src = (0, import_node_fs44.readFileSync)((0, import_node_path33.join)(repoRoot(), file), "utf8").split("\n");
           const at = src[line - 1];
           return at === void 0 ? null : lineSha(at);
         } catch {
@@ -24353,7 +24658,7 @@ function describeRelease(release, input) {
 
 // src/lib/memory-pull.ts
 var import_node_child_process14 = require("node:child_process");
-var import_promises15 = require("node:fs/promises");
+var import_promises16 = require("node:fs/promises");
 var pullStateFile = () => projectPath(`${VERITY_DIR}/.memory-pull-state.json`);
 var PAGE_SIZE = 200;
 var MAX_PAGES = 500;
@@ -24437,7 +24742,7 @@ async function recordServedFiles(served) {
 }
 async function readPullState() {
   try {
-    const parsed = JSON.parse(await (0, import_promises15.readFile)(pullStateFile(), "utf-8"));
+    const parsed = JSON.parse(await (0, import_promises16.readFile)(pullStateFile(), "utf-8"));
     const served = /* @__PURE__ */ new Map();
     if (parsed?.served && typeof parsed.served === "object") {
       for (const [path, hash] of Object.entries(parsed.served)) {
@@ -24451,8 +24756,8 @@ async function readPullState() {
 }
 async function writePullState(state) {
   try {
-    await (0, import_promises15.mkdir)(projectPath(VERITY_DIR), { recursive: true });
-    await (0, import_promises15.writeFile)(pullStateFile(), JSON.stringify({
+    await (0, import_promises16.mkdir)(projectPath(VERITY_DIR), { recursive: true });
+    await (0, import_promises16.writeFile)(pullStateFile(), JSON.stringify({
       ...state.version ? { version: state.version } : {},
       pulled_at: (/* @__PURE__ */ new Date()).toISOString(),
       served: Object.fromEntries(state.served)
@@ -24895,7 +25200,7 @@ function registerAnalyzeCommand(program2) {
 var tracing = () => process.env.VERITY_TRACE_PHASES === "1";
 async function runAnalyze(opts, globals) {
   if (!verityConfigured()) {
-    (0, import_node_fs44.writeSync)(2, '[verity] not set up in this project \u2014 run "verity init" first.\n');
+    (0, import_node_fs45.writeSync)(2, '[verity] not set up in this project \u2014 run "verity init" first.\n');
     process.exit(0);
   }
   const run2 = createRun(opts, globals);
@@ -24916,11 +25221,11 @@ async function runAnalyze(opts, globals) {
 }
 
 // src/commands/baseline.ts
-var import_node_fs46 = require("node:fs");
+var import_node_fs47 = require("node:fs");
 
 // src/lib/project-skills.ts
-var import_node_fs45 = require("node:fs");
-var import_node_path33 = require("node:path");
+var import_node_fs46 = require("node:fs");
+var import_node_path34 = require("node:path");
 var PROJECT_SKILL_NAMES = [
   "verity-setup",
   "verity-analyze",
@@ -24945,14 +25250,14 @@ var LEGACY_SKILL_NAMES = [
 var ALL = [...PROJECT_SKILL_NAMES, ...LEGACY_SKILL_NAMES];
 function staleProjectSkills() {
   const root = projectPath(".claude/skills");
-  if (!(0, import_node_fs45.existsSync)(root)) return [];
-  return ALL.filter((name) => (0, import_node_fs45.existsSync)((0, import_node_path33.join)(root, name)));
+  if (!(0, import_node_fs46.existsSync)(root)) return [];
+  return ALL.filter((name) => (0, import_node_fs46.existsSync)((0, import_node_path34.join)(root, name)));
 }
 function removeProjectSkills() {
   const root = projectPath(".claude/skills");
   const removed = [];
   for (const name of staleProjectSkills()) {
-    (0, import_node_fs45.rmSync)((0, import_node_path33.join)(root, name), { recursive: true, force: true });
+    (0, import_node_fs46.rmSync)((0, import_node_path34.join)(root, name), { recursive: true, force: true });
     removed.push(name);
   }
   return removed;
@@ -25017,13 +25322,13 @@ function registerBaselineCommands(program2) {
       let memoryMsg = null;
       let memoryAgentLine = null;
       const memoryNotice = projectPath(`${VERITY_DIR}/.memory-fence-notice`);
-      if (realStart && !(0, import_node_fs46.existsSync)(memoryNotice)) {
+      if (realStart && !(0, import_node_fs47.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");
+            (0, import_node_fs47.writeFileSync)(memoryNotice, (/* @__PURE__ */ new Date()).toISOString() + "\n");
           } catch {
           }
         }
@@ -25124,7 +25429,7 @@ function hookSource(value) {
 }
 
 // src/commands/review.ts
-var import_node_fs47 = require("node:fs");
+var import_node_fs48 = 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();
@@ -25143,7 +25448,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_fs47.existsSync)(f) || resolveFile(f) !== null);
+    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).filter((f) => (0, import_node_fs48.existsSync)(f) || resolveFile(f) !== null);
     staticResults = runCodacyAnalysis(scannable);
   } else {
     staticResults = {
@@ -25169,7 +25474,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_fs47.existsSync)(p)) continue;
+      if (!(0, import_node_fs48.existsSync)(p)) continue;
       try {
         const { readFileSync: readFileSync26 } = await import("node:fs");
         const content = readFileSync26(p, "utf-8");
@@ -25229,8 +25534,8 @@ async function runReview(opts, globals) {
 }
 
 // src/commands/guard.ts
-var import_node_fs48 = require("node:fs");
-var import_node_path34 = require("node:path");
+var import_node_fs49 = require("node:fs");
+var import_node_path35 = require("node:path");
 
 // src/lib/terminal-text.ts
 var CONTROL = /[\x00-\x08\x0b-\x1f\x7f-\x9f\u061c\u200e\u200f\u2028-\u202e\u2066-\u2069]/g;
@@ -25605,7 +25910,7 @@ async function buildAgentDiffs(ctx, paths, limits = { perFileChars: 24e3, totalC
 // src/commands/guard.ts
 var EXCERPT_SOURCE_MAX_BYTES = 2 * 1024 * 1024;
 var GUARD_BLOCK_CAP = 2;
-var GUARD_ITER_FILE = (0, import_node_path34.join)(VERITY_DIR, ".guard-iteration");
+var GUARD_ITER_FILE = (0, import_node_path35.join)(VERITY_DIR, ".guard-iteration");
 function readPreToolUseStdin() {
   const empty = { command: "", cwd: null, sessionId: null };
   return new Promise((resolve6) => {
@@ -25650,7 +25955,7 @@ function readPreToolUseStdin() {
 }
 function readIterMap() {
   try {
-    const raw = JSON.parse((0, import_node_fs48.readFileSync)(GUARD_ITER_FILE, "utf-8"));
+    const raw = JSON.parse((0, import_node_fs49.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 };
@@ -25670,10 +25975,10 @@ function readIter(moment) {
 }
 function writeIter(moment, count) {
   try {
-    (0, import_node_fs48.mkdirSync)(VERITY_DIR, { recursive: true });
+    (0, import_node_fs49.mkdirSync)(VERITY_DIR, { recursive: true });
     const map = readIterMap();
     map[moment] = count;
-    (0, import_node_fs48.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
+    (0, import_node_fs49.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
   } catch {
   }
 }
@@ -25683,10 +25988,10 @@ function resetIter(moment) {
     if (!(moment in map)) return;
     delete map[moment];
     if (Object.keys(map).length === 0) {
-      if ((0, import_node_fs48.existsSync)(GUARD_ITER_FILE)) (0, import_node_fs48.unlinkSync)(GUARD_ITER_FILE);
+      if ((0, import_node_fs49.existsSync)(GUARD_ITER_FILE)) (0, import_node_fs49.unlinkSync)(GUARD_ITER_FILE);
     } else {
-      (0, import_node_fs48.mkdirSync)(VERITY_DIR, { recursive: true });
-      (0, import_node_fs48.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
+      (0, import_node_fs49.mkdirSync)(VERITY_DIR, { recursive: true });
+      (0, import_node_fs49.writeFileSync)(GUARD_ITER_FILE, JSON.stringify(map));
     }
   } catch {
   }
@@ -25758,7 +26063,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_fs48.existsSync)(f) ? f : resolveFile(f)).filter((f) => f !== null);
+    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).map((f) => (0, import_node_fs49.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: [] } };
@@ -26261,7 +26566,7 @@ function registerIgnoreCommand(program2) {
 
 // src/commands/waive.ts
 var import_node_crypto12 = require("node:crypto");
-var import_node_fs49 = require("node:fs");
+var import_node_fs50 = 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();
@@ -26290,7 +26595,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_fs49.readFileSync)(opts.file)).digest("hex");
+        body.file_sha256 = (0, import_node_crypto12.createHash)("sha256").update((0, import_node_fs50.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);
@@ -26315,10 +26620,10 @@ function registerWaiveCommand(program2) {
 }
 
 // src/commands/init.ts
-var import_node_fs53 = require("node:fs");
-var import_promises18 = require("node:fs/promises");
+var import_node_fs54 = require("node:fs");
+var import_promises19 = require("node:fs/promises");
 var import_yaml6 = __toESM(require_dist());
-var import_node_path37 = require("node:path");
+var import_node_path38 = require("node:path");
 var import_node_child_process17 = require("node:child_process");
 
 // src/lib/banner.ts
@@ -26397,7 +26702,7 @@ function printPhase(n, of, title, subtitle) {
 }
 
 // src/commands/doctor.ts
-var import_node_fs50 = require("node:fs");
+var import_node_fs51 = require("node:fs");
 
 // src/lib/prereqs.ts
 var import_node_child_process15 = require("node:child_process");
@@ -26513,7 +26818,7 @@ async function checkPrereqs(opts = {}) {
 }
 
 // src/lib/telemetry.ts
-var import_promises16 = require("node:fs/promises");
+var import_promises17 = require("node:fs/promises");
 var SETTINGS_LOCAL_FILE2 = ".claude/settings.local.json";
 var GITIGNORE_FILE = ".gitignore";
 var GITIGNORE_ENTRY = SETTINGS_LOCAL_IGNORE_ENTRY;
@@ -26543,7 +26848,7 @@ function buildTelemetryEnv(serviceUrl) {
 var VERITY_TELEMETRY_KEYS = Object.keys(buildTelemetryEnv(""));
 async function readSettingsLocal() {
   try {
-    return JSON.parse(await (0, import_promises16.readFile)(projectPath(SETTINGS_LOCAL_FILE2), "utf-8"));
+    return JSON.parse(await (0, import_promises17.readFile)(projectPath(SETTINGS_LOCAL_FILE2), "utf-8"));
   } catch {
     return {};
   }
@@ -26555,7 +26860,7 @@ async function ensureGitignore() {
   const file = projectPath(GITIGNORE_FILE);
   let content = "";
   try {
-    content = await (0, import_promises16.readFile)(file, "utf-8");
+    content = await (0, import_promises17.readFile)(file, "utf-8");
   } catch {
   }
   const lines = content.split("\n").map((l) => l.trim());
@@ -26564,7 +26869,7 @@ async function ensureGitignore() {
   }
   const block = "# Verity telemetry \u2014 machine-local Claude Code settings\n" + GITIGNORE_ENTRY + "\n";
   const next = content ? content + (content.endsWith("\n") ? "" : "\n") + "\n" + block : block;
-  await (0, import_promises16.writeFile)(file, next);
+  await (0, import_promises17.writeFile)(file, next);
 }
 async function installTelemetry(serviceUrl) {
   const env = buildTelemetryEnv(serviceUrl);
@@ -26609,11 +26914,11 @@ async function buildReport() {
   const wiring = await resolveHookWiring();
   const hooks = wiring.status;
   const telemetry = await checkTelemetry();
-  const hasConfig = (0, import_node_fs50.existsSync)(projectPath(CODACY_CONFIG_FILE));
+  const hasConfig = (0, import_node_fs51.existsSync)(projectPath(CODACY_CONFIG_FILE));
   const artifacts = {
-    standard: (0, import_node_fs50.existsSync)(projectPath(STANDARD_FILE)),
+    standard: (0, import_node_fs51.existsSync)(projectPath(STANDARD_FILE)),
     analysisConfig: hasConfig,
-    verityMd: (0, import_node_fs50.existsSync)(projectPath(VERITY_MD_FILE)),
+    verityMd: (0, import_node_fs51.existsSync)(projectPath(VERITY_MD_FILE)),
     analysisConfigIds: hasConfig ? validatePatternIds().status : "absent"
   };
   const next = [];
@@ -26744,8 +27049,8 @@ function registerDoctorCommand(program2) {
 }
 
 // src/commands/migrate.ts
-var import_node_fs51 = require("node:fs");
-var import_node_path35 = require("node:path");
+var import_node_fs52 = require("node:fs");
+var import_node_path36 = require("node:path");
 var import_node_child_process16 = require("node:child_process");
 var LEGACY_NPM_PACKAGE = "@codacy/gate-cli";
 function defaultNpmRemover(pkg) {
@@ -26782,12 +27087,12 @@ async function runMigration(opts = {}) {
   return { actions, migrated: actions.length > 0 };
 }
 function migrateProjectDir(root, actions) {
-  const gateDir = (0, import_node_path35.join)(root, ".gate");
-  const verityDir = (0, import_node_path35.join)(root, ".verity");
-  if ((0, import_node_fs51.existsSync)(gateDir) && !(0, import_node_fs51.existsSync)(verityDir)) {
+  const gateDir = (0, import_node_path36.join)(root, ".gate");
+  const verityDir = (0, import_node_path36.join)(root, ".verity");
+  if ((0, import_node_fs52.existsSync)(gateDir) && !(0, import_node_fs52.existsSync)(verityDir)) {
     return migrateProjectDirRename(root, gateDir, verityDir, actions);
   }
-  if ((0, import_node_fs51.existsSync)(gateDir) && (0, import_node_fs51.existsSync)(verityDir)) {
+  if ((0, import_node_fs52.existsSync)(gateDir) && (0, import_node_fs52.existsSync)(verityDir)) {
     return migrateProjectDirCarry(gateDir, verityDir, actions);
   }
   return false;
@@ -26808,13 +27113,13 @@ function migrateProjectDirRename(root, gateDir, verityDir, actions) {
     }
   }
   if (moved) {
-    if ((0, import_node_fs51.existsSync)(gateDir)) {
+    if ((0, import_node_fs52.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_fs51.rmSync)(gateDir, { recursive: true, force: true });
+        (0, import_node_fs52.rmSync)(gateDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -26830,18 +27135,18 @@ function migrateProjectDirCarry(gateDir, verityDir, actions) {
     actions.push(`Carried ${carried} legacy file(s) from .gate/ into .verity/`);
   }
   try {
-    (0, import_node_fs51.rmSync)(gateDir, { recursive: true, force: true });
+    (0, import_node_fs52.rmSync)(gateDir, { recursive: true, force: true });
   } catch {
   }
   return carried > 0;
 }
 function migrateGlobalCredentials(home, actions) {
   if (!home) return;
-  const gateCreds = (0, import_node_path35.join)(home, ".gate", "credentials");
-  const verityCreds = (0, import_node_path35.join)(home, ".verity", "credentials");
-  if (!(0, import_node_fs51.existsSync)(gateCreds)) return;
-  if (!(0, import_node_fs51.existsSync)(verityCreds)) {
-    (0, import_node_fs51.mkdirSync)((0, import_node_path35.join)(home, ".verity"), { recursive: true });
+  const gateCreds = (0, import_node_path36.join)(home, ".gate", "credentials");
+  const verityCreds = (0, import_node_path36.join)(home, ".verity", "credentials");
+  if (!(0, import_node_fs52.existsSync)(gateCreds)) return;
+  if (!(0, import_node_fs52.existsSync)(verityCreds)) {
+    (0, import_node_fs52.mkdirSync)((0, import_node_path36.join)(home, ".verity"), { recursive: true });
     moveFile(gateCreds, verityCreds);
     actions.push("Moved ~/.gate/credentials \u2192 ~/.verity/credentials");
     return;
@@ -26863,8 +27168,8 @@ async function migrateLegacyHooks(root, actions) {
   }
 }
 async function migrateClaudeMd(root, actions) {
-  const claudeMd = (0, import_node_path35.join)(root, "CLAUDE.md");
-  const hadLegacyBlock = (0, import_node_fs51.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd));
+  const claudeMd = (0, import_node_path36.join)(root, "CLAUDE.md");
+  const hadLegacyBlock = (0, import_node_fs52.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd));
   if (!hadLegacyBlock) return;
   try {
     await ensureClaudeMdPointer(root);
@@ -26874,9 +27179,9 @@ async function migrateClaudeMd(root, actions) {
   }
 }
 function migrateStandardFile(root, actions) {
-  const gateMd = (0, import_node_path35.join)(root, "GATE.md");
-  const verityMd = (0, import_node_path35.join)(root, "VERITY.md");
-  if (!(0, import_node_fs51.existsSync)(gateMd) || (0, import_node_fs51.existsSync)(verityMd)) return;
+  const gateMd = (0, import_node_path36.join)(root, "GATE.md");
+  const verityMd = (0, import_node_path36.join)(root, "VERITY.md");
+  if (!(0, import_node_fs52.existsSync)(gateMd) || (0, import_node_fs52.existsSync)(verityMd)) return;
   let moved = false;
   if (isGitRepo(root) && isGitTracked(root, "GATE.md")) {
     try {
@@ -26888,12 +27193,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_fs51.writeFileSync)(verityMd, refreshed);
+  if (refreshed !== content) (0, import_node_fs52.writeFileSync)(verityMd, refreshed);
   actions.push("Renamed GATE.md \u2192 VERITY.md");
 }
 async function migrateTelemetryHeaders(root, actions) {
-  const file = (0, import_node_path35.join)(root, ".claude", "settings.local.json");
-  if (!(0, import_node_fs51.existsSync)(file)) return;
+  const file = (0, import_node_path36.join)(root, ".claude", "settings.local.json");
+  if (!(0, import_node_fs52.existsSync)(file)) return;
   let settings;
   try {
     settings = JSON.parse(readFileSyncSafe(file) || "{}");
@@ -26941,14 +27246,14 @@ function mergeGlobalCredentials(gateCreds, verityCreds) {
   }
   if (toAppend.length > 0) {
     const sep4 = verityContent.endsWith("\n") || verityContent === "" ? "" : "\n";
-    (0, import_node_fs51.writeFileSync)(verityCreds, verityContent + sep4 + toAppend.join("\n") + "\n");
+    (0, import_node_fs52.writeFileSync)(verityCreds, verityContent + sep4 + toAppend.join("\n") + "\n");
   }
-  (0, import_node_fs51.rmSync)(gateCreds, { force: true });
+  (0, import_node_fs52.rmSync)(gateCreds, { force: true });
   return toAppend.length;
 }
 function readFileSyncSafe(path) {
   try {
-    return (0, import_node_fs51.readFileSync)(path, "utf-8");
+    return (0, import_node_fs52.readFileSync)(path, "utf-8");
   } catch {
     return "";
   }
@@ -26963,35 +27268,35 @@ function hasStagedChanges(root) {
 }
 function moveDir(from, to) {
   try {
-    (0, import_node_fs51.renameSync)(from, to);
+    (0, import_node_fs52.renameSync)(from, to);
   } catch (err) {
     if (err.code !== "EXDEV") throw err;
-    (0, import_node_fs51.cpSync)(from, to, { recursive: true });
-    (0, import_node_fs51.rmSync)(from, { recursive: true, force: true });
+    (0, import_node_fs52.cpSync)(from, to, { recursive: true });
+    (0, import_node_fs52.rmSync)(from, { recursive: true, force: true });
   }
 }
 function moveFile(from, to) {
   try {
-    (0, import_node_fs51.renameSync)(from, to);
+    (0, import_node_fs52.renameSync)(from, to);
   } catch (err) {
     if (err.code !== "EXDEV") throw err;
-    (0, import_node_fs51.cpSync)(from, to);
-    (0, import_node_fs51.rmSync)(from, { force: true });
+    (0, import_node_fs52.cpSync)(from, to);
+    (0, import_node_fs52.rmSync)(from, { force: true });
   }
 }
 function carryLegacyContents(gateDir, verityDir) {
   let copied = 0;
   const walk2 = (relDir) => {
-    const srcDir = (0, import_node_path35.join)(gateDir, relDir);
-    for (const entry of (0, import_node_fs51.readdirSync)(srcDir)) {
-      const rel = relDir ? (0, import_node_path35.join)(relDir, entry) : entry;
-      const src = (0, import_node_path35.join)(gateDir, rel);
-      const dest = (0, import_node_path35.join)(verityDir, rel);
-      if ((0, import_node_fs51.statSync)(src).isDirectory()) {
+    const srcDir = (0, import_node_path36.join)(gateDir, relDir);
+    for (const entry of (0, import_node_fs52.readdirSync)(srcDir)) {
+      const rel = relDir ? (0, import_node_path36.join)(relDir, entry) : entry;
+      const src = (0, import_node_path36.join)(gateDir, rel);
+      const dest = (0, import_node_path36.join)(verityDir, rel);
+      if ((0, import_node_fs52.statSync)(src).isDirectory()) {
         walk2(rel);
-      } else if (!(0, import_node_fs51.existsSync)(dest)) {
-        (0, import_node_fs51.mkdirSync)((0, import_node_path35.dirname)(dest), { recursive: true });
-        (0, import_node_fs51.cpSync)(src, dest);
+      } else if (!(0, import_node_fs52.existsSync)(dest)) {
+        (0, import_node_fs52.mkdirSync)((0, import_node_path36.dirname)(dest), { recursive: true });
+        (0, import_node_fs52.cpSync)(src, dest);
         copied++;
       }
     }
@@ -27000,22 +27305,22 @@ function carryLegacyContents(gateDir, verityDir) {
   return copied;
 }
 async function needsMigration(root = repoRoot()) {
-  const gateDir = (0, import_node_path35.join)(root, ".gate");
-  const verityDir = (0, import_node_path35.join)(root, ".verity");
-  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_path35.join)(gateDir, "credentials")) && !(0, import_node_fs51.existsSync)((0, import_node_path35.join)(verityDir, "credentials"))) {
+  const gateDir = (0, import_node_path36.join)(root, ".gate");
+  const verityDir = (0, import_node_path36.join)(root, ".verity");
+  if ((0, import_node_fs52.existsSync)(gateDir) && !(0, import_node_fs52.existsSync)(verityDir)) return true;
+  if ((0, import_node_fs52.existsSync)(gateDir) && (0, import_node_fs52.existsSync)(verityDir)) {
+    if ((0, import_node_fs52.existsSync)((0, import_node_path36.join)(gateDir, "credentials")) && !(0, import_node_fs52.existsSync)((0, import_node_path36.join)(verityDir, "credentials"))) {
       return true;
     }
-    if ((0, import_node_fs51.existsSync)((0, import_node_path35.join)(gateDir, "memory")) && !(0, import_node_fs51.existsSync)((0, import_node_path35.join)(verityDir, "memory"))) {
+    if ((0, import_node_fs52.existsSync)((0, import_node_path36.join)(gateDir, "memory")) && !(0, import_node_fs52.existsSync)((0, import_node_path36.join)(verityDir, "memory"))) {
       return true;
     }
   }
-  const claudeMd = (0, import_node_path35.join)(root, "CLAUDE.md");
-  if ((0, import_node_fs51.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd))) {
+  const claudeMd = (0, import_node_path36.join)(root, "CLAUDE.md");
+  if ((0, import_node_fs52.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd))) {
     return true;
   }
-  if ((0, import_node_fs51.existsSync)((0, import_node_path35.join)(root, "GATE.md")) && !(0, import_node_fs51.existsSync)((0, import_node_path35.join)(root, "VERITY.md"))) {
+  if ((0, import_node_fs52.existsSync)((0, import_node_path36.join)(root, "GATE.md")) && !(0, import_node_fs52.existsSync)((0, import_node_path36.join)(root, "VERITY.md"))) {
     return true;
   }
   if (await hasLegacyHooksAt(root)) return true;
@@ -27296,9 +27601,9 @@ async function promptMultiSelect(question, choices, fallback) {
 }
 
 // src/lib/remote-config.ts
-var import_node_fs52 = require("node:fs");
-var import_promises17 = require("node:fs/promises");
-var import_node_path36 = require("node:path");
+var import_node_fs53 = require("node:fs");
+var import_promises18 = require("node:fs/promises");
+var import_node_path37 = require("node:path");
 var import_yaml5 = __toESM(require_dist());
 var IGNORE_RIDER = "verityignore";
 async function fetchRemoteSetup(opts) {
@@ -27343,11 +27648,11 @@ async function adoptRemoteSetup(found, opts) {
   written.push(STANDARD_FILE);
   if (rider !== null) {
     const localIgnore = projectPath(VERITYIGNORE_FILE);
-    if (!(0, import_node_fs52.existsSync)(localIgnore)) {
+    if (!(0, import_node_fs53.existsSync)(localIgnore)) {
       await writeOut(VERITYIGNORE_FILE, rider);
       written.push(VERITYIGNORE_FILE);
     } else {
-      const local = await (0, import_promises17.readFile)(localIgnore, "utf-8").catch(() => null);
+      const local = await (0, import_promises18.readFile)(localIgnore, "utf-8").catch(() => null);
       if (local !== null && local !== rider) {
         notes.push(`${VERITYIGNORE_FILE} already exists here and differs from the pushed copy \u2014 kept yours.`);
       }
@@ -27376,8 +27681,8 @@ async function adoptRemoteSetup(found, opts) {
 }
 async function writeOut(relative2, body) {
   const target = projectPath(relative2);
-  await (0, import_promises17.mkdir)((0, import_node_path36.dirname)(target), { recursive: true });
-  await (0, import_promises17.writeFile)(target, body);
+  await (0, import_promises18.mkdir)((0, import_node_path37.dirname)(target), { recursive: true });
+  await (0, import_promises18.writeFile)(target, body);
 }
 function describeRemote(found) {
   const when = found.standard.createdAt.slice(0, 10);
@@ -27493,15 +27798,15 @@ async function runOptionalAuth(resolution, opts = {}) {
 }
 function resolveDataDir2() {
   const candidates2 = [
-    (0, import_node_path37.join)(__dirname, "..", "data"),
+    (0, import_node_path38.join)(__dirname, "..", "data"),
     // installed: node_modules/@codacy/verity-cli/data
-    (0, import_node_path37.join)(__dirname, "..", "..", "data"),
+    (0, import_node_path38.join)(__dirname, "..", "..", "data"),
     // edge case: nested resolution
-    (0, import_node_path37.join)(process.cwd(), "cli", "data")
+    (0, import_node_path38.join)(process.cwd(), "cli", "data")
     // local dev: running from repo root
   ];
   for (const candidate of candidates2) {
-    if ((0, import_node_fs53.existsSync)((0, import_node_path37.join)(candidate, "skills"))) {
+    if ((0, import_node_fs54.existsSync)((0, import_node_path38.join)(candidate, "skills"))) {
       return candidate;
     }
   }
@@ -27510,16 +27815,16 @@ function resolveDataDir2() {
   );
 }
 async function copyDir(src, dest) {
-  await (0, import_promises18.mkdir)(dest, { recursive: true });
-  await (0, import_promises18.cp)(src, dest, { recursive: true, force: true });
+  await (0, import_promises19.mkdir)(dest, { recursive: true });
+  await (0, import_promises19.cp)(src, dest, { recursive: true, force: true });
 }
 async function skillIsCurrent(src, dest) {
   const list2 = (dir) => {
     const out = [];
     const walk2 = (d, prefix) => {
-      for (const e of (0, import_node_fs53.readdirSync)(d, { withFileTypes: true })) {
+      for (const e of (0, import_node_fs54.readdirSync)(d, { withFileTypes: true })) {
         const rel = prefix ? `${prefix}/${e.name}` : e.name;
-        if (e.isDirectory()) walk2((0, import_node_path37.join)(d, e.name), rel);
+        if (e.isDirectory()) walk2((0, import_node_path38.join)(d, e.name), rel);
         else if (e.isFile()) out.push(rel);
       }
     };
@@ -27530,8 +27835,8 @@ async function skillIsCurrent(src, dest) {
     const shipped = list2(src);
     if (JSON.stringify(shipped) !== JSON.stringify(list2(dest))) return false;
     for (const rel of shipped) {
-      const a = await (0, import_promises18.readFile)((0, import_node_path37.join)(src, rel), "utf-8");
-      const b = await (0, import_promises18.readFile)((0, import_node_path37.join)(dest, rel), "utf-8");
+      const a = await (0, import_promises19.readFile)((0, import_node_path38.join)(src, rel), "utf-8");
+      const b = await (0, import_promises19.readFile)((0, import_node_path38.join)(dest, rel), "utf-8");
       if (a !== b) return false;
     }
     return true;
@@ -27712,13 +28017,13 @@ async function synthesizeLocally(opts) {
 async function healStaleAnalysisConfig(globals) {
   const configPath = projectPath(CODACY_CONFIG_FILE);
   const standardPath = projectPath(STANDARD_FILE);
-  if (!(0, import_node_fs53.existsSync)(configPath) || !(0, import_node_fs53.existsSync)(standardPath)) return;
+  if (!(0, import_node_fs54.existsSync)(configPath) || !(0, import_node_fs54.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");
   printWarn("  running silently with nothing enabled. Re-deriving it from your Standard\u2026");
   try {
-    const content = (0, import_yaml6.parse)(await (0, import_promises18.readFile)(standardPath, "utf-8"));
+    const content = (0, import_yaml6.parse)(await (0, import_promises19.readFile)(standardPath, "utf-8"));
     const derived = await deriveConfigForStandard(content);
     for (const path of derived.written) printInfo(`  ${path} \u2713 (re-derived)`);
     for (const note of derived.notes) printWarn(`  ${note}`);
@@ -27809,17 +28114,17 @@ async function handoffToSetup(enabled, claudeInstalled) {
 async function installSkills(force, step) {
   step("Installing skills");
   const dataDir = resolveDataDir2();
-  const skillsSource = (0, import_node_path37.join)(dataDir, "skills");
+  const skillsSource = (0, import_node_path38.join)(dataDir, "skills");
   const skillsDest = ".claude/skills";
   let skillsInstalled = 0;
   for (const skill of SKILLS) {
-    const src = (0, import_node_path37.join)(skillsSource, skill);
-    const dest = (0, import_node_path37.join)(skillsDest, skill);
-    if (!(0, import_node_fs53.existsSync)(src)) {
+    const src = (0, import_node_path38.join)(skillsSource, skill);
+    const dest = (0, import_node_path38.join)(skillsDest, skill);
+    if (!(0, import_node_fs54.existsSync)(src)) {
       printWarn(`  Skill data not found: ${skill}`);
       continue;
     }
-    if ((0, import_node_fs53.existsSync)(dest) && !force && await skillIsCurrent(src, dest)) {
+    if ((0, import_node_fs54.existsSync)(dest) && !force && await skillIsCurrent(src, dest)) {
       skillsInstalled++;
       continue;
     }
@@ -27883,7 +28188,7 @@ async function checkPrerequisites(step) {
 }
 async function scaffoldProject(step, defaultsOnly) {
   step("Knowledge base, .gitignore and CLAUDE.md");
-  await (0, import_promises18.mkdir)(VERITY_DIR, { recursive: true });
+  await (0, import_promises19.mkdir)(VERITY_DIR, { recursive: true });
   await ensureMemoryDir();
   const ignoreResult = ensureVerityGitignore();
   if (ignoreResult === "failed") {
@@ -27958,7 +28263,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_fs53.existsSync)(m));
+    const isProject = projectMarkers.some((m) => (0, import_node_fs54.existsSync)(m));
     if (!isProject) {
       printError("No project detected in the current directory.");
       printInfo('Run "verity init" from your project root.');
@@ -28048,8 +28353,8 @@ function registerInitCommand(program2) {
       printInfo(`  intensity: ${intensity} \xB7 moments: ${moments.join(", ") || "none"} (no questions asked)`);
     }
     await scaffoldProject(step, defaultsOnly);
-    const globalVerityDir = (0, import_node_path37.join)(process.env.HOME ?? "", ".verity");
-    await (0, import_promises18.mkdir)(globalVerityDir, { recursive: true });
+    const globalVerityDir = (0, import_node_path38.join)(process.env.HOME ?? "", ".verity");
+    await (0, import_promises19.mkdir)(globalVerityDir, { recursive: true });
     console.log("");
     step("Wiring Claude Code hooks");
     const gitMoments = [
@@ -28117,7 +28422,7 @@ function registerInitCommand(program2) {
     }
     step("Your project's Standard");
     let haveStandard = false;
-    if ((0, import_node_fs53.existsSync)(projectPath(STANDARD_FILE))) {
+    if ((0, import_node_fs54.existsSync)(projectPath(STANDARD_FILE))) {
       printInfo("  This project already has .verity/standard.yaml \u2014 keeping it.");
       haveStandard = true;
     } else {
@@ -28147,7 +28452,7 @@ function registerInitCommand(program2) {
         ...telemetryChoice ? { telemetry: telemetryChoice } : {},
         init: {
           completed_at: (/* @__PURE__ */ new Date()).toISOString(),
-          cli_version: true ? "0.32.6-experimental.8f2b5f7" : "dev"
+          cli_version: true ? "0.32.6-experimental.df0a578" : "dev"
         }
       });
     } catch (err) {
@@ -28197,8 +28502,8 @@ function registerInitCommand(program2) {
 }
 
 // src/commands/uninstall.ts
-var import_node_fs54 = require("node:fs");
-var import_node_path38 = require("node:path");
+var import_node_fs55 = require("node:fs");
+var import_node_path39 = 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) => {
     const dryRun = opts.dryRun ?? false;
@@ -28207,11 +28512,11 @@ function registerUninstallCommand(program2) {
     const actions = [];
     const skillsRoot = projectPath(".claude/skills");
     for (const name of PROJECT_SKILL_NAMES) {
-      const dir = (0, import_node_path38.join)(skillsRoot, name);
-      if ((0, import_node_fs54.existsSync)(dir)) {
+      const dir = (0, import_node_path39.join)(skillsRoot, name);
+      if ((0, import_node_fs55.existsSync)(dir)) {
         actions.push({
           label: `Remove .claude/skills/${name}/`,
-          apply: () => (0, import_node_fs54.rmSync)(dir, { recursive: true, force: true })
+          apply: () => (0, import_node_fs55.rmSync)(dir, { recursive: true, force: true })
         });
       }
     }
@@ -28225,24 +28530,24 @@ function registerUninstallCommand(program2) {
       });
     }
     const verityDir = projectPath(VERITY_DIR);
-    if ((0, import_node_fs54.existsSync)(verityDir)) {
+    if ((0, import_node_fs55.existsSync)(verityDir)) {
       actions.push({
         label: `Remove ${VERITY_DIR}/`,
-        apply: () => (0, import_node_fs54.rmSync)(verityDir, { recursive: true, force: true })
+        apply: () => (0, import_node_fs55.rmSync)(verityDir, { recursive: true, force: true })
       });
     }
     if (!keepVerityMd) {
       const verityMd = projectPath(VERITY_MD_FILE);
-      if ((0, import_node_fs54.existsSync)(verityMd)) {
+      if ((0, import_node_fs55.existsSync)(verityMd)) {
         actions.push({
           label: `Remove ${VERITY_MD_FILE}`,
-          apply: () => (0, import_node_fs54.rmSync)(verityMd, { force: true })
+          apply: () => (0, import_node_fs55.rmSync)(verityMd, { force: true })
         });
       }
     }
     const cleanupEmptyDir = (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);
+      if ((0, import_node_fs55.existsSync)(path) && (0, import_node_fs55.statSync)(path).isDirectory() && (0, import_node_fs55.readdirSync)(path).length === 0) {
+        (0, import_node_fs55.rmdirSync)(path);
       }
     };
     actions.push({
@@ -28253,11 +28558,11 @@ function registerUninstallCommand(program2) {
       }
     });
     const home = process.env.HOME ?? "";
-    const globalVerityDir = (0, import_node_path38.join)(home, ".verity");
-    if (purgeGlobal && (0, import_node_fs54.existsSync)(globalVerityDir)) {
+    const globalVerityDir = (0, import_node_path39.join)(home, ".verity");
+    if (purgeGlobal && (0, import_node_fs55.existsSync)(globalVerityDir)) {
       actions.push({
         label: `Remove ~/.verity/ (global credentials \u2014 reconnect requires re-registration)`,
-        apply: () => (0, import_node_fs54.rmSync)(globalVerityDir, { recursive: true, force: true })
+        apply: () => (0, import_node_fs55.rmSync)(globalVerityDir, { recursive: true, force: true })
       });
     }
     if (actions.length === 0) {
@@ -28451,8 +28756,8 @@ function registerTaskCommands(program2) {
 }
 
 // src/commands/reset.ts
-var import_node_fs55 = require("node:fs");
-var import_node_path39 = require("node:path");
+var import_node_fs56 = require("node:fs");
+var import_node_path40 = 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) => {
     const globals = program2.opts();
@@ -28489,11 +28794,11 @@ function registerResetCommand(program2) {
     }
     const cacheDir = projectPath(CACHE_DIR);
     let purged = 0;
-    if ((0, import_node_fs55.existsSync)(cacheDir)) {
-      for (const entry of (0, import_node_fs55.readdirSync)(cacheDir)) {
+    if ((0, import_node_fs56.existsSync)(cacheDir)) {
+      for (const entry of (0, import_node_fs56.readdirSync)(cacheDir)) {
         if (entry.startsWith("pending-")) {
           try {
-            (0, import_node_fs55.unlinkSync)((0, import_node_path39.join)(cacheDir, entry));
+            (0, import_node_fs56.unlinkSync)((0, import_node_path40.join)(cacheDir, entry));
             purged++;
           } catch {
           }
@@ -28508,19 +28813,19 @@ function registerResetCommand(program2) {
       projectPath(`${VERITY_DIR}/.last-analysis`)
     ];
     for (const file of filesToClear) {
-      if ((0, import_node_fs55.existsSync)(file)) {
+      if ((0, import_node_fs56.existsSync)(file)) {
         try {
-          (0, import_node_fs55.writeFileSync)(file, "");
+          (0, import_node_fs56.writeFileSync)(file, "");
         } catch {
         }
       }
     }
     if (opts.all) {
       const logsDir = projectPath(`${VERITY_DIR}/.logs`);
-      if ((0, import_node_fs55.existsSync)(logsDir)) {
-        for (const entry of (0, import_node_fs55.readdirSync)(logsDir)) {
+      if ((0, import_node_fs56.existsSync)(logsDir)) {
+        for (const entry of (0, import_node_fs56.readdirSync)(logsDir)) {
           try {
-            (0, import_node_fs55.unlinkSync)((0, import_node_path39.join)(logsDir, entry));
+            (0, import_node_fs56.unlinkSync)((0, import_node_path40.join)(logsDir, entry));
           } catch {
           }
         }
@@ -28532,7 +28837,7 @@ function registerResetCommand(program2) {
 }
 
 // src/commands/reflect.ts
-var import_node_fs56 = require("node:fs");
+var import_node_fs57 = require("node:fs");
 
 // src/lib/reflection-globs.ts
 var MAX_GLOBS = 6;
@@ -28570,7 +28875,7 @@ async function writeNodeToDisk(args) {
       { treePaths: listTrackedFiles(), recordBaseline: false }
     );
     if (written === 0) return false;
-    return (0, import_node_fs56.existsSync)(projectPath(`${VERITY_DIR}/memory/${args.filePath}`));
+    return (0, import_node_fs57.existsSync)(projectPath(`${VERITY_DIR}/memory/${args.filePath}`));
   } catch {
     return false;
   }
@@ -28815,6 +29120,88 @@ function registerMemoryCommand(program2) {
     if (!quiet) {
       printInfo(result.status === "unchanged" ? "Knowledge graph is up to date." : result.status === "tracked" ? "Skipped: .verity/memory/ is tracked by git here, and the pull never rewrites tracked files. Run `verity memory untrack` to make the graph machine-local." : `Pulled ${result.received} node(s); ${result.written} new or updated file(s) written to .verity/memory/.`);
     }
+    let org;
+    try {
+      org = await pullOrgKnowledge({
+        serviceUrl: urlResult.data,
+        token: tokenResult.data.token,
+        verbose: globals.verbose,
+        force: !!opts.force
+      });
+    } catch (err) {
+      org = { ok: false, error: err.message };
+    }
+    logEvent("memory_org_pull", org.ok ? { status: org.status, received: org.received } : { status: "failed", category: org.category ?? null });
+    if (!quiet) {
+      if (!org.ok) printWarn(`Could not refresh the org knowledge mirror: ${org.error}`);
+      else if (org.status === "pulled") printInfo(`Org knowledge: ${org.received} claim(s) mirrored at ${org.dir}.`);
+      else if (org.status === "unchanged") printInfo("Org knowledge mirror is up to date.");
+    }
+    process.exit(0);
+  });
+  memory.command("org").description("List the org knowledge mirrored for this repository's organization").action(async () => {
+    try {
+      process.chdir(repoRoot());
+    } catch {
+    }
+    const dir = orgMirrorDir();
+    if (!dir) {
+      printError("Not a repository with an origin remote, so there is no organization to list.");
+      process.exit(1);
+    }
+    const claims = await readOrgMirror();
+    if (claims.length === 0) {
+      printInfo(`No org knowledge mirrored yet (${dir}). Run \`verity memory pull\`.`);
+      process.exit(0);
+    }
+    for (const c of claims) console.log(`${c.tag_id}  ${c.kind.padEnd(11)} ${c.title}  \xB7 ${c.origin}`);
+    printInfo(`${claims.length} claim(s) at ${dir}. Demote one with \`verity memory demote <id> --reason "\u2026"\`.`);
+    process.exit(0);
+  });
+  memory.command("demote <claim-id>").description("Demote an org knowledge claim for the whole organization, with a reason").requiredOption("--reason <text>", "Why this claim should no longer be shared (1\u2013500 characters)").action(async (claimId, opts) => {
+    const globals = program2.opts();
+    try {
+      process.chdir(repoRoot());
+    } catch {
+    }
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(claimId)) {
+      printError("The claim id is the `id` in the mirrored file, a uuid. `verity memory org` lists them.");
+      process.exit(1);
+    }
+    const reason = opts.reason.trim();
+    if (reason.length === 0 || reason.length > 500) {
+      printError("--reason is 1 to 500 characters.");
+      process.exit(1);
+    }
+    const tokenResult = await resolveToken(globals.token);
+    if (!tokenResult.ok) {
+      printError(tokenResult.error);
+      process.exit(1);
+    }
+    const urlResult = await resolveServiceUrl(globals.serviceUrl);
+    if (!urlResult.ok) {
+      printError(urlResult.error);
+      process.exit(1);
+    }
+    const res = await apiRequest({
+      method: "POST",
+      path: `/memory/org/claims/${claimId}/demote`,
+      serviceUrl: urlResult.data,
+      token: tokenResult.data.token,
+      body: { reason },
+      verbose: globals.verbose,
+      cmd: "memory-demote",
+      extraHeaders: { "X-Verity-Via": "cli" }
+    });
+    if (!res.ok) {
+      printError(`Could not demote the claim: ${res.error}`);
+      process.exit(1);
+    }
+    printInfo(`Demoted ${claimId} for the whole organization. Restore it from the dashboard if that was wrong.`);
+    try {
+      await pullOrgKnowledge({ serviceUrl: urlResult.data, token: tokenResult.data.token, verbose: globals.verbose, force: true });
+    } catch {
+    }
     process.exit(0);
   });
   memory.command("untrack").description("Stop committing .verity/memory/ \u2014 the graph stays on disk and leaves your diffs").action(() => {
@@ -28980,8 +29367,8 @@ function registerTelemetryCommands(program2) {
 }
 
 // src/cli.ts
-program.name("verity").description("CLI for Verity quality gate service").version("0.32.6-experimental.8f2b5f7").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-experimental.8f2b5f7");
+program.name("verity").description("CLI for Verity quality gate service").version("0.32.6-experimental.df0a578").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-experimental.df0a578");
   setUserNamedServiceUrl(program.opts().serviceUrl);
   try {
     await foldLegacyLocalCredential();