@inerrata-corporation/errata 2.0.14-dev.3228 → 2.0.14-dev.3236

package/errata.mjs

@@ -22636,14 +22636,14 @@ function localMoving(nodeIds, g) {
   return community;
 }
 function refineConnectivity(community, g) {
-  const members2 = /* @__PURE__ */ new Map();
+  const members = /* @__PURE__ */ new Map();
   for (const [id, c] of community) {
-    const l = members2.get(c) ?? [];
+    const l = members.get(c) ?? [];
     l.push(id);
-    members2.set(c, l);
+    members.set(c, l);
   }
   const refined = /* @__PURE__ */ new Map();
-  for (const [, group] of members2) {
+  for (const [, group] of members) {
     const inGroup = new Set(group);
     const seen = /* @__PURE__ */ new Set();
     for (const start2 of [...group].sort()) {
@@ -23562,7 +23562,7 @@ function sharedScope(l2, memberIds) {
   const versionRange = shared("versionRange");
   return { ...lang ? { lang } : {}, ...versionRange ? { versionRange } : {} };
 }
-function buildCandidate(id, ts, members2, contexts, originMachine, scope) {
+function buildCandidate(id, ts, members, contexts, originMachine, scope) {
   return {
     id,
     label: "Claim",
@@ -23588,7 +23588,7 @@ function buildCandidate(id, ts, members2, contexts, originMachine, scope) {
       pendingDistillation: true,
       // membership is the unit of truth — the harness validates its fence against
       // this set (P3 / C3) and may only phrase, never alter, it.
-      members: members2,
+      members,
       memberContexts: contexts,
       distinctContexts: contexts.length,
       // standard Claim envelope so it crystallizes/syncs unchanged once distilled
@@ -23660,14 +23660,14 @@ function induceAbstractions(l2, opts) {
   }
   const comm = detectCommunitiesLeiden({ nodeIds: [...ids], adj }, { protect });
   report.communities = comm.count;
-  const members2 = /* @__PURE__ */ new Map();
+  const members = /* @__PURE__ */ new Map();
   for (const [id, c] of comm.community) {
-    const l = members2.get(c) ?? [];
+    const l = members.get(c) ?? [];
     l.push(id);
-    members2.set(c, l);
+    members.set(c, l);
   }
   l2.transaction(() => {
-    for (const mem of members2.values()) {
+    for (const mem of members.values()) {
       if (opts.touched && !mem.some((id) => opts.touched.has(id))) continue;
       if (mem.length < K) {
         report.skippedSmall++;
@@ -23709,14 +23709,14 @@ function pendingAbstractions(l2) {
     if (Number(n.attrs["abstractionLevel"] ?? ABSTRACTION_LEVEL.CONCRETE) < ABSTRACTION_LEVEL.PRINCIPLE) continue;
     if (n.attrs["provisional"] !== true) continue;
     const memberIds = Array.isArray(n.attrs["members"]) ? n.attrs["members"] : [];
-    const members2 = memberIds.map((id) => {
+    const members = memberIds.map((id) => {
       const m = l2.getNode(id);
       return m ? { id: m.id, label: m.label, description: m.description } : { id, label: "?", description: "(member missing)" };
     });
     out2.push({
       candidate: n.id,
       distinctContexts: Number(n.attrs["distinctContexts"] ?? 0),
-      members: members2
+      members
     });
   }
   return out2;
@@ -23746,10 +23746,10 @@ function applyAbstractionFence(l2, fence, ts) {
   if (node2.attrs["provisional"] !== true) {
     return { applied: false, principleId: fence.candidate, reason: "candidate already distilled" };
   }
-  const members2 = Array.isArray(node2.attrs["members"]) ? node2.attrs["members"] : [];
-  const want = new Set(members2);
+  const members = Array.isArray(node2.attrs["members"]) ? node2.attrs["members"] : [];
+  const want = new Set(members);
   const got = new Set(fence.covers);
-  const missing = members2.filter((id) => !got.has(id));
+  const missing = members.filter((id) => !got.has(id));
   const invented = fence.covers.filter((id) => !want.has(id));
   if (missing.length > 0 || invented.length > 0) {
     return {
@@ -23780,10 +23780,10 @@ function revisitContradictedPrinciples(l2, ts) {
     for (const n of l2.findNodesByLabel("Claim")) {
       if (Number(n.attrs["abstractionLevel"] ?? ABSTRACTION_LEVEL.CONCRETE) < ABSTRACTION_LEVEL.PRINCIPLE) continue;
       if (n.attrs["revisit"] === true) continue;
-      const members2 = Array.isArray(n.attrs["members"]) ? n.attrs["members"] : [];
-      const memberSet = new Set(members2);
+      const members = Array.isArray(n.attrs["members"]) ? n.attrs["members"] : [];
+      const memberSet = new Set(members);
       let reason = "";
-      for (const id of members2) {
+      for (const id of members) {
         const m = l2.getNode(id);
         if (!m) {
           reason = `member ${id} was removed`;
@@ -23874,14 +23874,14 @@ function detectLocalCommunities(store, opts = {}) {
     }
   }
   const comm = detectCommunitiesLeiden({ nodeIds: [...ids], adj }, { protect });
-  const members2 = /* @__PURE__ */ new Map();
+  const members = /* @__PURE__ */ new Map();
   for (const [id, c] of comm.community) {
-    const l = members2.get(c) ?? [];
+    const l = members.get(c) ?? [];
     l.push(id);
-    members2.set(c, l);
+    members.set(c, l);
   }
   store.transaction(() => {
-    for (const [cid, mem] of members2) {
+    for (const [cid, mem] of members) {
       const qualifies = mem.length >= minSize;
       let hasLocal = false;
       let hasCloud = false;
@@ -30904,8 +30904,8 @@ var init_generalizer = __esm({
 function layerOf(kind) {
   return kind === "Technique" ? "technique" : kind === "AntiPattern" ? "antipattern" : "pattern";
 }
-function motifTitle(members2, layer, instanceCount) {
-  const top = [...members2].sort(
+function motifTitle(members, layer, instanceCount) {
+  const top = [...members].sort(
     (a, b) => b.extractionConfidence - a.extractionConfidence
   )[0];
   return `${layer} \xD7${instanceCount} (exemplar): ${top?.description ?? "recurring problem cluster"}`;
@@ -30934,17 +30934,17 @@ function promoteMotifs(store, t) {
   let techniques = 0;
   let antipatterns = 0;
   store.transaction(() => {
-    for (const [cid, members2] of byCommunity) {
-      const instances = members2.filter((m) => m.label === "Problem");
-      const instanceCount = instances.length || members2.length;
+    for (const [cid, members] of byCommunity) {
+      const instances = members.filter((m) => m.label === "Problem");
+      const instanceCount = instances.length || members.length;
       const motifId = `motif_${cid}`;
       const existing = store.getNode(motifId);
       const d = motifDecision({
-        instances: members2.map((m) => ({
+        instances: members.map((m) => ({
           confidence: m.extractionConfidence,
           failed: false
         })),
-        memberCount: members2.length,
+        memberCount: members.length,
         instanceCount,
         priorSurvivedRuns: existing?.attrs["survivedRuns"] ?? 0
       });
@@ -30956,7 +30956,7 @@ function promoteMotifs(store, t) {
         label: kind,
         // Refresh the deterministic title every run (exemplar/count/kind drift),
         // but never clobber a distilled one — a distillation pass owns it then.
-        description: existing?.attrs["titleDistilled"] === true ? existing.description : motifTitle(members2, layerOf(kind), instanceCount),
+        description: existing?.attrs["titleDistilled"] === true ? existing.description : motifTitle(members, layerOf(kind), instanceCount),
         extractionConfidence: d.motifConfidence,
         extractionSource: "bko-inferred",
         embedding: existing?.embedding ?? [],
@@ -30975,7 +30975,7 @@ function promoteMotifs(store, t) {
           communityId: cid,
           survivedRuns: d.survivedRuns,
           motifConfidence: d.motifConfidence,
-          memberCount: members2.length,
+          memberCount: members.length,
           instanceCount,
           promoted: d.promoted
         }
@@ -31996,47 +31996,43 @@ var init_recall_card = __esm({
 });
 
 // src/recall-signal.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join7 } from "node:path";
 function live(n) {
   return n != null && n.validTo == null && historyReadPolicy(n, { mode: "passive" }).allow;
 }
 function isPlaceholderFix(n) {
   return n.label === "Solution" && (n.description ?? "").startsWith(AUTO_MINT_PREFIX);
 }
-function causalChains(store, problems, scoreOf) {
-  const best = (ids) => ids.sort((a, b) => scoreOf(b.id) - scoreOf(a.id))[0];
+function causalChains(store, problems) {
+  const newest = (nodes) => nodes.sort((a, b) => b.lastUpdatedAt - a.lastUpdatedAt)[0];
   const chains = [];
   for (const problem of problems) {
-    const causes = store.outEdges(problem.id, ["CAUSED_BY"]).map((e) => store.getNode(e.to)).filter((n) => live(n) && n.label === "RootCause");
-    const fixes = store.outEdges(problem.id, ["SOLVED_BY"]).map((e) => store.getNode(e.to)).filter((n) => live(n) && n.label === "Solution" && !isPlaceholderFix(n));
-    const cause = best(causes);
-    const fix = best(fixes);
+    const cause = newest(
+      store.outEdges(problem.id, ["CAUSED_BY"]).map((e) => store.getNode(e.to)).filter((n) => live(n) && n.label === "RootCause")
+    );
+    const fix = newest(
+      store.outEdges(problem.id, ["SOLVED_BY"]).map((e) => store.getNode(e.to)).filter((n) => live(n) && n.label === "Solution" && !isPlaceholderFix(n))
+    );
     if (cause || fix) chains.push({ problem, ...cause ? { cause } : {}, ...fix ? { fix } : {} });
   }
   return chains;
 }
-function members(c) {
-  return [c.problem, c.cause, c.fix].filter((n) => n != null);
-}
-function pickChain(chains, scoreOf) {
-  const mean = (c) => {
-    const m = members(c);
-    return m.reduce((s, n) => s + scoreOf(n.id), 0) / m.length;
-  };
-  return chains.filter((c) => scoreOf(c.problem.id) > 0).sort((a, b) => members(b).length - members(a).length || mean(b) - mean(a))[0];
-}
 function item(n) {
   return { label: n.label, text: n.description ?? "" };
 }
-function signalCard(headline, ranked, chains, chainScores = /* @__PURE__ */ new Map()) {
-  if (ranked.length === 0 && chains.length === 0) return null;
-  const score2 = new Map([...chainScores, ...ranked.map((r) => [r.id, r.score])]);
-  const scoreOf = (id) => score2.get(id) ?? 0;
-  const chain2 = pickChain(chains, scoreOf);
-  const inChain = new Set(chain2 ? members(chain2).map((n) => n.id) : []);
-  const single = ranked.find((r) => r.score > 0 && !inChain.has(r.id))?.node;
+function deliveredPrior(n) {
+  return { id: n.id, label: n.label, text: n.description ?? "" };
+}
+function deliveredCard(store, headline, delivered) {
+  if (delivered.length === 0) return null;
+  const problems = delivered.filter((d) => d.label === "Problem").map((d) => store.getNode(d.id)).filter((n) => live(n));
+  const chain2 = causalChains(store, problems)[0];
+  const inChain = new Set(chain2 ? [chain2.problem.id, chain2.cause?.id, chain2.fix?.id] : []);
+  const single = delivered.find((d) => !inChain.has(d.id));
   return {
     headline,
-    items: ranked.map((r) => item(r.node)),
+    items: delivered.map((d) => ({ label: d.label, text: d.text })),
     ...chain2 ? {
       chain: {
         problem: item(chain2.problem),
@@ -32044,19 +32040,43 @@ function signalCard(headline, ranked, chains, chainScores = /* @__PURE__ */ new
         ...chain2.fix ? { fix: item(chain2.fix) } : {}
       }
     } : {},
-    ...single ? { single: item(single) } : {}
+    ...single ? { single: { label: single.label, text: single.text } } : {}
   };
 }
-function promptPool(store, limit = 150) {
-  const problems = [...openProblems(store)].sort((a, b) => b.lastUpdatedAt - a.lastUpdatedAt).slice(0, limit);
-  const ids = new Set(problems.map((p) => p.id));
-  for (const p of problems) {
-    for (const e of store.outEdges(p.id, ["CAUSED_BY", "SOLVED_BY"])) {
-      const n = store.getNode(e.to);
-      if (live(n) && !isPlaceholderFix(n)) ids.add(n.id);
-    }
+function clipIntent(text, width = 48) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > width ? `${flat.slice(0, width - 1)}\u2026` : flat;
+}
+function contextCard(store, snapshot) {
+  const seen = /* @__PURE__ */ new Set();
+  const delivered = [];
+  const add = (n) => {
+    if (!n.id || seen.has(n.id)) return;
+    seen.add(n.id);
+    delivered.push(deliveredPrior(n));
+  };
+  for (const h of snapshot.statedIntent?.hits ?? []) add(h);
+  for (const h of snapshot.statedIntent?.remoteHits ?? []) add(h);
+  for (const p of snapshot.workingFile?.priors?.openProblems ?? []) add({ ...p, label: "Problem" });
+  for (const r of snapshot.recentProblems) add(r.node);
+  for (const n of snapshot.remote ?? []) add(n);
+  for (const m of snapshot.motifs) add(m);
+  const count = plural(delivered.length, "prior");
+  const intent = snapshot.statedIntent?.text;
+  return deliveredCard(store, intent ? `${count} for \u201C${clipIntent(intent)}\u201D` : `${count} in context`, delivered);
+}
+function writeContextCard(root, hash2, card) {
+  writeFileSync6(join7(root, ".errata", CONTEXT_CARD_FILE), JSON.stringify({ hash: hash2, card }));
+}
+function readContextCard(root, hash2) {
+  const path2 = join7(root, ".errata", CONTEXT_CARD_FILE);
+  if (!existsSync7(path2)) return null;
+  try {
+    const saved = JSON.parse(readFileSync5(path2, "utf8"));
+    return saved.hash === hash2 ? saved.card ?? null : null;
+  } catch {
+    return null;
   }
-  return { problems, ids: [...ids] };
 }
 function openProblems(store, now = Date.now()) {
   const hit = openProblemsCache.get(store);
@@ -32065,60 +32085,34 @@ function openProblems(store, now = Date.now()) {
   openProblemsCache.set(store, { at: now, nodes });
   return nodes;
 }
-async function promptRecallCard(store, prompt) {
-  const { problems, ids } = promptPool(store);
-  if (ids.length === 0) return null;
-  const ranked = await rankForText(store, prompt.slice(0, 2e3), ids);
-  const matched = promptMatches(ranked);
-  if (matched.length === 0) return null;
-  const score2 = new Map(ranked.map((r) => [r.id, r.score]));
-  const matchedIds = new Set(matched.map((r) => r.id));
-  const chains = causalChains(store, problems.filter((p) => matchedIds.has(p.id)), (id) => score2.get(id) ?? 0);
-  const verb = matched.length === 1 ? "matches" : "match";
-  const card = signalCard(`${plural(matched.length, "prior")} ${verb} this prompt`, matched, chains, score2);
-  return card && { ...card, moreWhere: "matching" };
-}
-function promptMatches(ranked, sigmas = 3.5) {
-  const sims = ranked.map((r) => r.components.semantic ?? 0);
-  if (sims.length < 3) return [...ranked];
-  const median = (xs) => {
-    const s = [...xs].sort((a, b) => a - b);
-    const m = s.length >> 1;
-    return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
-  };
-  const center = median(sims);
-  const sigma = 1.4826 * median(sims.map((x) => Math.abs(x - center)));
-  if (sigma === 0) return [];
-  return ranked.map((r, i2) => ({ r, sim: sims[i2] })).filter((x) => x.sim >= center + sigmas * sigma).sort((a, b) => b.sim - a.sim || b.r.score - a.r.score).map((x) => x.r);
-}
 function openProblemCount(store) {
   return openProblems(store).length;
 }
-var OPEN_PROBLEMS_TTL_MS, openProblemsCache;
+var CONTEXT_CARD_FILE, OPEN_PROBLEMS_TTL_MS, openProblemsCache;
 var init_recall_signal = __esm({
   "src/recall-signal.ts"() {
     "use strict";
     init_src5();
     init_src();
-    init_src8();
     init_recall_card();
+    CONTEXT_CARD_FILE = "context-card.json";
     OPEN_PROBLEMS_TTL_MS = 6e4;
     openProblemsCache = /* @__PURE__ */ new WeakMap();
   }
 });
 
 // src/review.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "node:fs";
 function loadReviewQueue(paths) {
-  if (!existsSync7(paths.reviewQueue)) return [];
+  if (!existsSync8(paths.reviewQueue)) return [];
   try {
-    return JSON.parse(readFileSync5(paths.reviewQueue, "utf8"));
+    return JSON.parse(readFileSync6(paths.reviewQueue, "utf8"));
   } catch {
     return [];
   }
 }
 function saveReviewQueue(paths, queue) {
-  writeFileSync6(paths.reviewQueue, JSON.stringify(queue, null, 2), "utf8");
+  writeFileSync7(paths.reviewQueue, JSON.stringify(queue, null, 2), "utf8");
 }
 function addProposal(paths, store, node2, reason, surprise) {
   const queue = loadReviewQueue(paths);
@@ -32188,14 +32182,14 @@ var init_consent = __esm({
 });
 
 // src/git-remote.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6, statSync } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join7, resolve } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync7, statSync } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join8, resolve } from "node:path";
 function resolveGitDir(root) {
-  const dotGit = join7(root, ".git");
+  const dotGit = join8(root, ".git");
   try {
     const st = statSync(dotGit);
     if (st.isDirectory()) return dotGit;
-    const m = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync6(dotGit, "utf8"));
+    const m = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync7(dotGit, "utf8"));
     if (!m) return null;
     const dir = m[1];
     return isAbsolute2(dir) ? dir : resolve(root, dir);
@@ -32204,22 +32198,22 @@ function resolveGitDir(root) {
   }
 }
 function gitConfigPath(gitDir) {
-  const commondirFile = join7(gitDir, "commondir");
-  if (existsSync8(commondirFile)) {
-    const common = readFileSync6(commondirFile, "utf8").trim();
+  const commondirFile = join8(gitDir, "commondir");
+  if (existsSync9(commondirFile)) {
+    const common = readFileSync7(commondirFile, "utf8").trim();
     const commonDir = isAbsolute2(common) ? common : resolve(gitDir, common);
-    return join7(commonDir, "config");
+    return join8(commonDir, "config");
   }
-  return join7(gitDir, "config");
+  return join8(gitDir, "config");
 }
 function readRemotes(root) {
   const gitDir = resolveGitDir(root);
   if (!gitDir) return [];
   const cfgPath = gitConfigPath(gitDir);
-  if (!existsSync8(cfgPath)) return [];
+  if (!existsSync9(cfgPath)) return [];
   let txt;
   try {
-    txt = readFileSync6(cfgPath, "utf8");
+    txt = readFileSync7(cfgPath, "utf8");
   } catch {
     return [];
   }
@@ -32245,9 +32239,9 @@ var init_git_remote = __esm({
 });
 
 // src/profile.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "node:fs";
 import { createHash as createHash5 } from "node:crypto";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 function workspaceId(root) {
   return "wp_" + createHash5("sha256").update(root).digest("hex").slice(0, 12);
 }
@@ -32270,13 +32264,13 @@ function refreshRepoLocator(root, profile) {
 }
 function loadProfile(root) {
   const p = workspacePaths(root);
-  if (!existsSync9(p.workspaceJson)) return null;
-  return JSON.parse(readFileSync7(p.workspaceJson, "utf8"));
+  if (!existsSync10(p.workspaceJson)) return null;
+  return JSON.parse(readFileSync8(p.workspaceJson, "utf8"));
 }
 function saveProfile(root, profile) {
   const p = workspacePaths(root);
   ensureDir(p.configDir);
-  writeFileSync7(p.workspaceJson, JSON.stringify(profile, null, 2), "utf8");
+  writeFileSync8(p.workspaceJson, JSON.stringify(profile, null, 2), "utf8");
 }
 function autodetectProfile(root) {
   const id = workspaceId(root);
@@ -32284,13 +32278,13 @@ function autodetectProfile(root) {
   const p = emptyProfile(id, name2);
   const locator = detectRepoLocator(root);
   if (locator) p.repoLocator = locator;
-  const pkgPath = join8(root, "package.json");
-  if (existsSync9(pkgPath)) {
+  const pkgPath = join9(root, "package.json");
+  if (existsSync10(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
       const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
       p.languages.push("javascript");
-      if (existsSync9(join8(root, "tsconfig.json")) || deps["typescript"]) {
+      if (existsSync10(join9(root, "tsconfig.json")) || deps["typescript"]) {
         p.languages.push("typescript");
       }
       const nodeVer = pkg.engines?.node?.trim();
@@ -32311,10 +32305,10 @@ function autodetectProfile(root) {
     } catch {
     }
   }
-  const pyproject = join8(root, "pyproject.toml");
-  if (existsSync9(pyproject)) {
+  const pyproject = join9(root, "pyproject.toml");
+  if (existsSync10(pyproject)) {
     try {
-      const txt = readFileSync7(pyproject, "utf8");
+      const txt = readFileSync8(pyproject, "utf8");
       const py = /python\s*=\s*"([^"]+)"/.exec(txt)?.[1];
       p.languages.push("python");
       p.stack.push(`python@${py ?? "3"}`);
@@ -32325,16 +32319,16 @@ function autodetectProfile(root) {
     } catch {
     }
   }
-  const reqs = join8(root, "requirements.txt");
-  if (existsSync9(reqs)) {
+  const reqs = join9(root, "requirements.txt");
+  if (existsSync10(reqs)) {
     if (!p.languages.includes("python")) p.languages.push("python");
     if (!p.stack.includes("python@3")) p.stack.push("python@3");
   }
-  if (existsSync9(join8(root, "go.mod"))) {
+  if (existsSync10(join9(root, "go.mod"))) {
     p.languages.push("go");
     p.stack.push("go");
   }
-  if (existsSync9(join8(root, "Cargo.toml"))) {
+  if (existsSync10(join9(root, "Cargo.toml"))) {
     p.languages.push("rust");
     p.stack.push("rust");
   }
@@ -32439,12 +32433,12 @@ var init_identity2 = __esm({
 });
 
 // src/checkout-root.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "node:fs";
-import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join9, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "node:fs";
+import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join10, resolve as resolve2 } from "node:path";
 function nearestGitRoot(dir) {
   let cur = resolve2(dir);
   for (; ; ) {
-    if (existsSync10(join9(cur, ".git"))) return cur;
+    if (existsSync11(join10(cur, ".git"))) return cur;
     const parent = dirname6(cur);
     if (parent === cur) return null;
     cur = parent;
@@ -32452,19 +32446,19 @@ function nearestGitRoot(dir) {
 }
 function mainCheckoutOfWorktree(root) {
   const gitDir = resolveGitDir(root);
-  if (!gitDir || gitDir === join9(root, ".git")) return null;
-  const commondirFile = join9(gitDir, "commondir");
-  if (!existsSync10(commondirFile)) return null;
+  if (!gitDir || gitDir === join10(root, ".git")) return null;
+  const commondirFile = join10(gitDir, "commondir");
+  if (!existsSync11(commondirFile)) return null;
   let common;
   try {
-    common = readFileSync8(commondirFile, "utf8").trim();
+    common = readFileSync9(commondirFile, "utf8").trim();
   } catch {
     return null;
   }
   const commonDir = resolve2(isAbsolute3(common) ? common : resolve2(gitDir, common));
   if (basename2(commonDir) !== ".git") return null;
   const main2 = dirname6(commonDir);
-  return existsSync10(join9(main2, ".git")) ? main2 : null;
+  return existsSync11(join10(main2, ".git")) ? main2 : null;
 }
 function checkoutRootOf(cwd) {
   const root = nearestGitRoot(cwd);
@@ -32482,16 +32476,16 @@ var init_checkout_root = __esm({
 });
 
 // src/registry.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join11 } from "node:path";
 function registryPath() {
-  return process.env["ERRATA_REGISTRY_PATH"] ?? join10(globalDir(), "workspaces.json");
+  return process.env["ERRATA_REGISTRY_PATH"] ?? join11(globalDir(), "workspaces.json");
 }
 function read() {
   const p = registryPath();
-  if (!existsSync11(p)) return { version: 1, workspaces: {} };
+  if (!existsSync12(p)) return { version: 1, workspaces: {} };
   try {
-    const parsed = JSON.parse(readFileSync9(p, "utf8"));
+    const parsed = JSON.parse(readFileSync10(p, "utf8"));
     return { version: 1, workspaces: parsed.workspaces ?? {} };
   } catch {
     return { version: 1, workspaces: {} };
@@ -32499,9 +32493,9 @@ function read() {
 }
 function registryCorrupt() {
   const p = registryPath();
-  if (!existsSync11(p)) return false;
+  if (!existsSync12(p)) return false;
   try {
-    JSON.parse(readFileSync9(p, "utf8"));
+    JSON.parse(readFileSync10(p, "utf8"));
     return false;
   } catch {
     return true;
@@ -32509,7 +32503,7 @@ function registryCorrupt() {
 }
 function write(reg) {
   ensureDir(globalDir());
-  writeFileSync8(registryPath(), JSON.stringify(reg, null, 2), "utf8");
+  writeFileSync9(registryPath(), JSON.stringify(reg, null, 2), "utf8");
 }
 function registerWorkspace(profile, root, now = Date.now()) {
   if (isLinkedWorktree(root)) return;
@@ -32554,7 +32548,7 @@ function pruneMissingWorkspaces() {
   const reg = read();
   const removed = [];
   for (const [id, entry] of Object.entries(reg.workspaces)) {
-    if (!existsSync11(entry.path)) {
+    if (!existsSync12(entry.path)) {
       removed.push(entry);
       delete reg.workspaces[id];
     }
@@ -32563,13 +32557,13 @@ function pruneMissingWorkspaces() {
   return removed;
 }
 function workspaceStatus(entry) {
-  const missing = !existsSync11(entry.path);
+  const missing = !existsSync12(entry.path);
   const lockPath = workspacePaths(entry.path).daemonLock;
   let running = false;
   let webUiUrl = null;
-  if (existsSync11(lockPath)) {
+  if (existsSync12(lockPath)) {
     try {
-      const lock = JSON.parse(readFileSync9(lockPath, "utf8"));
+      const lock = JSON.parse(readFileSync10(lockPath, "utf8"));
       if (lock.pid && lock.webUiUrl && pidAlive(lock.pid)) {
         running = true;
         webUiUrl = lock.webUiUrl;
@@ -33894,22 +33888,22 @@ var init_dual_augment = __esm({
 
 // ../../packages/indexer/src/parse-cache.ts
 import { createHash as createHash6 } from "node:crypto";
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync10, readdirSync as readdirSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync11, readdirSync as readdirSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync10 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function parseCacheDir() {
-  return process.env["ERRATA_PARSE_CACHE"] ?? join11(homedir3(), ".errata", "parse-cache");
+  return process.env["ERRATA_PARSE_CACHE"] ?? join12(homedir3(), ".errata", "parse-cache");
 }
 function parseCacheKey(source, providerId) {
   return createHash6("sha256").update(`${PARSE_CACHE_VERSION}:${providerId}:${source}`).digest("hex");
 }
 function entryPath(dir, key) {
-  return join11(dir, key.slice(0, 2), `${key.slice(2)}.json`);
+  return join12(dir, key.slice(0, 2), `${key.slice(2)}.json`);
 }
 function readParseCache(dir, key) {
   const file2 = entryPath(dir, key);
   try {
-    const raw2 = readFileSync10(file2, "utf8");
+    const raw2 = readFileSync11(file2, "utf8");
     const parsed = JSON.parse(raw2);
     if (parsed.v !== PARSE_CACHE_VERSION || !Array.isArray(parsed.symbols)) return null;
     return { symbols: parsed.symbols, reExports: parsed.reExports ?? [] };
@@ -33928,8 +33922,8 @@ function writeParseCache(dir, key, providerId, value) {
     const body2 = JSON.stringify(envelope);
     if (body2.length > MAX_ENTRY_BYTES) return;
     const file2 = entryPath(dir, key);
-    mkdirSync6(join11(dir, key.slice(0, 2)), { recursive: true });
-    writeFileSync9(file2, body2);
+    mkdirSync6(join12(dir, key.slice(0, 2)), { recursive: true });
+    writeFileSync10(file2, body2);
   } catch {
   }
 }
@@ -33938,9 +33932,9 @@ function sweepParseCacheOnce(dir, now = Date.now()) {
   sweptThisProcess = true;
   let removed = 0;
   try {
-    if (!existsSync12(dir)) return 0;
+    if (!existsSync13(dir)) return 0;
     for (const bucket of readdirSync2(dir)) {
-      const bucketDir = join11(dir, bucket);
+      const bucketDir = join12(dir, bucket);
       let names;
       try {
         names = readdirSync2(bucketDir);
@@ -33948,7 +33942,7 @@ function sweepParseCacheOnce(dir, now = Date.now()) {
         continue;
       }
       for (const name2 of names) {
-        const file2 = join11(bucketDir, name2);
+        const file2 = join12(bucketDir, name2);
         try {
           if (now - statSync2(file2).mtimeMs > ENTRY_TTL_MS) {
             rmSync2(file2, { force: true });
@@ -34196,9 +34190,9 @@ var init_identity3 = __esm({
 });
 
 // ../../packages/indexer/src/pipeline.ts
-import { appendFileSync, readFileSync as readFileSync11, statSync as statSync3 } from "node:fs";
+import { appendFileSync, readFileSync as readFileSync12, statSync as statSync3 } from "node:fs";
 import { readdir } from "node:fs/promises";
-import { extname, join as join12, relative as relative2, sep } from "node:path";
+import { extname, join as join13, relative as relative2, sep } from "node:path";
 import { createHash as createHash7 } from "node:crypto";
 import { execFileSync } from "node:child_process";
 function nowTs() {
@@ -34336,7 +34330,7 @@ async function incrementalReindex(store, rootPath, workspaceId2, changedAbsPaths
   for (const rel of [...changedRelPaths]) {
     let h;
     try {
-      h = createHash7("sha256").update(readFileSync11(join12(rootPath, rel))).digest("hex");
+      h = createHash7("sha256").update(readFileSync12(join13(rootPath, rel))).digest("hex");
     } catch {
       continue;
     }
@@ -34385,13 +34379,13 @@ async function incrementalReindex(store, rootPath, workspaceId2, changedAbsPaths
   let parsedFiles = 0;
   for (const rel of changedRelPaths) {
     if (parsedFiles++ > 0) await new Promise((r2) => setImmediate(r2));
-    const abs = join12(rootPath, ...rel.split("/"));
+    const abs = join13(rootPath, ...rel.split("/"));
     const ext = extname(abs).toLowerCase();
     const provider = providers.find((p) => p.fileExtensions.includes(ext));
     if (!provider) continue;
     let symbols;
     try {
-      symbols = provider.extractSymbols(readFileSync11(abs, "utf8"), abs);
+      symbols = provider.extractSymbols(readFileSync12(abs, "utf8"), abs);
     } catch {
       continue;
     }
@@ -34711,7 +34705,7 @@ async function runIndexer(store, opts) {
         report.filesSkipped++;
         continue;
       }
-      source = readFileSync11(f.absPath, "utf8");
+      source = readFileSync12(f.absPath, "utf8");
     } catch {
       report.filesSkipped++;
       continue;
@@ -34783,7 +34777,7 @@ async function runIndexer(store, opts) {
     const depth = fileNode.relPath.split("/").length;
     if (depth !== 3) continue;
     try {
-      const pkg = JSON.parse(readFileSync11(fileNode.absPath, "utf8"));
+      const pkg = JSON.parse(readFileSync12(fileNode.absPath, "utf8"));
       if (!pkg.name) continue;
       const pkgDir = fileNode.relPath.replace(/\/package\.json$/, "");
       const candidates = [
@@ -35171,7 +35165,7 @@ async function scan(root, current, ignores, providers, out2) {
   for (const ent of entries) {
     if (ignores.has(ent.name)) continue;
     if (ent.name.startsWith(".") && ent.name !== ".") continue;
-    const abs = join12(current, ent.name);
+    const abs = join13(current, ent.name);
     if (ent.isDirectory()) {
       await scan(root, abs, ignores, providers, out2);
     } else if (ent.isFile()) {
@@ -35230,7 +35224,7 @@ function gitListFiles(root, ignores, providers) {
   if (rels === null) return null;
   const out2 = [];
   for (const rel of rels) {
-    const abs = join12(root, rel);
+    const abs = join13(root, rel);
     let size;
     let mtimeMs;
     try {
@@ -35259,7 +35253,7 @@ function upsertFile(store, id, f, workspaceId2, skip) {
   if (existing && fileUnchanged(existing.attrs, f, skip)) return;
   let contentHash;
   try {
-    contentHash = createHash7("sha256").update(readFileSync11(f.absPath)).digest("hex");
+    contentHash = createHash7("sha256").update(readFileSync12(f.absPath)).digest("hex");
   } catch {
   }
   const carried = { ...existing?.attrs ?? {} };
@@ -39642,8 +39636,8 @@ ${JSON.stringify(symbolNames, null, 2)}`);
 
 // ../../packages/indexer/src/languages/tree-sitter-loader.ts
 import { fileURLToPath } from "node:url";
-import { dirname as dirname7, join as join13 } from "node:path";
-import { existsSync as existsSync13, readdirSync as readdirSync3 } from "node:fs";
+import { dirname as dirname7, join as join14 } from "node:path";
+import { existsSync as existsSync14, readdirSync as readdirSync3 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 function entryDir() {
   try {
@@ -39657,27 +39651,27 @@ function entryDir() {
 }
 function findWasmDir() {
   const here = entryDir();
-  const seaWasm = join13(here, "resources", "wasm");
-  if (existsSync13(join13(seaWasm, "tree-sitter-typescript.wasm"))) return seaWasm;
+  const seaWasm = join14(here, "resources", "wasm");
+  if (existsSync14(join14(seaWasm, "tree-sitter-typescript.wasm"))) return seaWasm;
   let dir = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const flat = join13(
+    const flat = join14(
       dir,
       "node_modules",
       "@vscode",
       "tree-sitter-wasm",
       "wasm"
     );
-    if (existsSync13(join13(flat, "tree-sitter-typescript.wasm"))) return flat;
+    if (existsSync14(join14(flat, "tree-sitter-typescript.wasm"))) return flat;
     dir = dirname7(dir);
   }
   let root = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const pnpmDir = join13(root, "node_modules", ".pnpm");
-    if (existsSync13(pnpmDir)) {
+    const pnpmDir = join14(root, "node_modules", ".pnpm");
+    if (existsSync14(pnpmDir)) {
       for (const entry of readdirSync3(pnpmDir)) {
         if (entry.startsWith("@vscode+tree-sitter-wasm@")) {
-          const candidate = join13(
+          const candidate = join14(
             pnpmDir,
             entry,
             "node_modules",
@@ -39685,7 +39679,7 @@ function findWasmDir() {
             "tree-sitter-wasm",
             "wasm"
           );
-          if (existsSync13(join13(candidate, "tree-sitter-typescript.wasm"))) {
+          if (existsSync14(join14(candidate, "tree-sitter-typescript.wasm"))) {
             return candidate;
           }
         }
@@ -39699,27 +39693,27 @@ function findWasmDir() {
 }
 function findRuntimeDir() {
   const here = entryDir();
-  const seaRuntime = join13(here, "resources", "wasm");
-  if (existsSync13(join13(seaRuntime, "web-tree-sitter.wasm"))) return seaRuntime;
+  const seaRuntime = join14(here, "resources", "wasm");
+  if (existsSync14(join14(seaRuntime, "web-tree-sitter.wasm"))) return seaRuntime;
   let dir = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const flat = join13(dir, "node_modules", "web-tree-sitter");
-    if (existsSync13(join13(flat, "web-tree-sitter.wasm"))) return flat;
+    const flat = join14(dir, "node_modules", "web-tree-sitter");
+    if (existsSync14(join14(flat, "web-tree-sitter.wasm"))) return flat;
     dir = dirname7(dir);
   }
   let root = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const pnpmDir = join13(root, "node_modules", ".pnpm");
-    if (existsSync13(pnpmDir)) {
+    const pnpmDir = join14(root, "node_modules", ".pnpm");
+    if (existsSync14(pnpmDir)) {
       for (const entry of readdirSync3(pnpmDir)) {
         if (entry.startsWith("web-tree-sitter@")) {
-          const candidate = join13(
+          const candidate = join14(
             pnpmDir,
             entry,
             "node_modules",
             "web-tree-sitter"
           );
-          if (existsSync13(join13(candidate, "web-tree-sitter.wasm"))) {
+          if (existsSync14(join14(candidate, "web-tree-sitter.wasm"))) {
             return candidate;
           }
         }
@@ -39736,7 +39730,7 @@ async function loadWebTreeSitter() {
     void err2;
   }
   const here = entryDir();
-  const seaResourceBase = join13(here, "resources", "_resolve.js");
+  const seaResourceBase = join14(here, "resources", "_resolve.js");
   const resourceRequire = createRequire2(seaResourceBase);
   return resourceRequire("web-tree-sitter");
 }
@@ -39751,9 +39745,9 @@ async function ensureTreeSitterReady() {
     await Parser2.init({
       locateFile: (name2) => {
         if (name2 === "tree-sitter.wasm" || name2 === "web-tree-sitter.wasm") {
-          return join13(runtime, name2);
+          return join14(runtime, name2);
         }
-        return join13(grammars, name2);
+        return join14(grammars, name2);
       }
     });
   })();
@@ -39765,7 +39759,7 @@ async function loadGrammar(name2) {
   if (cached2) return cached2;
   if (!languageClass) throw new Error("tree-sitter not initialized");
   const grammars = findWasmDir();
-  const lang = await languageClass.load(join13(grammars, `${name2}.wasm`));
+  const lang = await languageClass.load(join14(grammars, `${name2}.wasm`));
   grammarCache.set(name2, lang);
   return lang;
 }
@@ -42670,7 +42664,7 @@ var init_src11 = __esm({
 // src/reconcile.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { readdirSync as readdirSync4, statSync as statSync4 } from "node:fs";
-import { join as join14, relative as relative3, sep as sep2 } from "node:path";
+import { join as join15, relative as relative3, sep as sep2 } from "node:path";
 function indexerWouldScan(rel) {
   for (const seg of rel.split(/[\\/]/)) {
     if (seg.length === 0) continue;
@@ -42693,7 +42687,7 @@ function gitSourceFiles(root) {
   const out2 = [];
   for (const rel of stdout.split("\0")) {
     if (!rel || !SOURCE_RE.test(rel) || !indexerWouldScan(rel)) continue;
-    const abs = join14(root, rel);
+    const abs = join15(root, rel);
     if (IGNORED.test(abs)) continue;
     out2.push(abs);
   }
@@ -42708,7 +42702,7 @@ function* walkSource(dir) {
   }
   for (const e of entries) {
     const name2 = String(e.name);
-    const full = join14(dir, name2);
+    const full = join15(dir, name2);
     if (IGNORED.test(full)) continue;
     if (!indexerWouldScan(name2)) continue;
     if (e.isDirectory()) yield* walkSource(full);
@@ -42858,7 +42852,7 @@ __export(mcp_exports, {
   runTool: () => runTool,
   searchGraph: () => searchGraph
 });
-import { existsSync as existsSync14, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "node:fs";
 import { resolve as resolve3 } from "node:path";
 function collectEnrichmentPulls(store, opts = {}) {
   const pending = store.findNodesByLabel("Solution").filter((s) => s.attrs["enrichmentPending"] === true).filter((s) => !opts.onlyUnsurfaced || s.attrs["enrichmentSurfaced"] !== true);
@@ -42895,7 +42889,7 @@ function takeEnrichmentNudge(store) {
 ` + items;
 }
 function takeDiscriminatorNudge(path2) {
-  if (!path2 || !existsSync14(path2)) return null;
+  if (!path2 || !existsSync15(path2)) return null;
   let shared;
   try {
     shared = openGraphStore({ path: path2 });
@@ -43026,10 +43020,10 @@ function showNode(store, node2, maxLines) {
   if (!relPath) return { found: false, reason: "no file owner for node" };
   const workspaceRoot = process.cwd();
   const absPath = resolve3(workspaceRoot, relPath);
-  if (!existsSync14(absPath)) {
+  if (!existsSync15(absPath)) {
     return { found: false, reason: `file not found on disk: ${absPath}` };
   }
-  const source = readFileSync12(absPath, "utf8");
+  const source = readFileSync13(absPath, "utf8");
   const attrs = node2.attrs;
   let startByte = attrs["bodyStartByte"] ?? attrs["startByte"];
   let endByte = attrs["bodyEndByte"] ?? attrs["endByte"];
@@ -43786,7 +43780,7 @@ var init_mcp = __esm({
           const local = causalChain(store, { seedId: id, direction: "both", maxHops, limit });
           try {
             const path2 = sharedStorePath();
-            if (!existsSync14(path2)) return { found: true, ...local };
+            if (!existsSync15(path2)) return { found: true, ...local };
             const shared = openGraphStore({ path: path2 });
             try {
               if (!shared.getNode(id)) return { found: true, ...local };
@@ -44387,7 +44381,7 @@ var init_mcp = __esm({
         inputSchema: { type: "object", properties: {} },
         handler: () => {
           const path2 = sharedStorePath();
-          if (!existsSync14(path2)) return { count: 0, pending: [] };
+          if (!existsSync15(path2)) return { count: 0, pending: [] };
           const shared = openGraphStore({ path: path2 });
           try {
             const pending = pendingAbstractions(shared);
@@ -44415,7 +44409,7 @@ var init_mcp = __esm({
         },
         handler: (args2) => {
           const path2 = sharedStorePath();
-          if (!existsSync14(path2)) return { count: 0, pending: [] };
+          if (!existsSync15(path2)) return { count: 0, pending: [] };
           const shared = openGraphStore({ path: path2 });
           try {
             const pending = pendingDiscriminators(shared, {
@@ -44459,7 +44453,7 @@ var init_mcp = __esm({
         },
         handler: (args2) => {
           const path2 = sharedStorePath();
-          if (!existsSync14(path2)) return { count: 0, routes: [] };
+          if (!existsSync15(path2)) return { count: 0, routes: [] };
           const shared = openGraphStore({ path: path2 });
           try {
             const result = triageOf(shared, {
@@ -44844,8 +44838,8 @@ __export(vfile_exports, {
   resolvePath: () => resolvePath,
   segmentsOf: () => segmentsOf
 });
-import { writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join15, resolve as resolve4, sep as sep3 } from "node:path";
+import { writeFileSync as writeFileSync11 } from "node:fs";
+import { join as join16, resolve as resolve4, sep as sep3 } from "node:path";
 function segmentsOf(rawPath) {
   let p = rawPath.replace(/\\/g, "/");
   p = p.replace(/^.*\.errata\/g\//, "").replace(/^\/?g\//, "").replace(/^\/+/, "");
@@ -44919,14 +44913,14 @@ async function renderVFile(rawPath, store, ctx = {}) {
 }
 async function materializeVFile(rawPath, workspaceRoot, store, ctx = {}) {
   const segs = segmentsOf(rawPath);
-  const gRoot = join15(workspaceRoot, ".errata", "g");
+  const gRoot = join16(workspaceRoot, ".errata", "g");
   const abs = resolve4(gRoot, ...segs.length ? segs : ["index"]);
   if (abs !== gRoot && !abs.startsWith(gRoot + sep3)) {
     throw new Error(`refusing to materialize outside .errata/g: ${rawPath}`);
   }
   const text = await renderVFile(rawPath, store, ctx);
   ensureParent(abs);
-  writeFileSync10(abs, text, "utf8");
+  writeFileSync11(abs, text, "utf8");
   return abs;
 }
 async function materializeOverview(workspaceRoot, store, ctx = {}) {
@@ -52346,25 +52340,25 @@ var init_tool_index = __esm({
 
 // src/outbox.ts
 import {
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync13,
+  readFileSync as readFileSync14,
   renameSync,
   unlinkSync,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync12
 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 import { createHash as createHash15 } from "node:crypto";
 function enqueueOutbox(paths, payload) {
   ensureDir(paths.outbox);
   const id = createHash15("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 16);
-  const file2 = join16(paths.outbox, `${Date.now()}-${id}.json`);
-  writeFileSync11(file2, JSON.stringify(payload, null, 2), "utf8");
+  const file2 = join17(paths.outbox, `${Date.now()}-${id}.json`);
+  writeFileSync12(file2, JSON.stringify(payload, null, 2), "utf8");
   return file2;
 }
 async function flushOutbox(paths, client, store) {
   ensureDir(paths.outbox);
-  const entries = existsSync15(paths.outbox) ? readdirSync5(paths.outbox) : [];
+  const entries = existsSync16(paths.outbox) ? readdirSync5(paths.outbox) : [];
   let uploaded = 0;
   let failed = 0;
   const quarantine = (abs, reason) => {
@@ -52375,10 +52369,10 @@ async function flushOutbox(paths, client, store) {
     }
   };
   for (const f of entries.filter((e) => e.endsWith(".json")).sort()) {
-    const abs = join16(paths.outbox, f);
+    const abs = join17(paths.outbox, f);
     let payload;
     try {
-      payload = JSON.parse(readFileSync13(abs, "utf8"));
+      payload = JSON.parse(readFileSync14(abs, "utf8"));
     } catch {
       failed++;
       quarantine(abs, "unparseable JSON");
@@ -52423,7 +52417,7 @@ async function flushOutbox(paths, client, store) {
       }
     }
   }
-  const remainingFiles = existsSync15(paths.outbox) ? readdirSync5(paths.outbox).filter((e) => e.endsWith(".json")) : [];
+  const remainingFiles = existsSync16(paths.outbox) ? readdirSync5(paths.outbox).filter((e) => e.endsWith(".json")) : [];
   return { uploaded, failed, remaining: remainingFiles.length };
 }
 var init_outbox = __esm({
@@ -52562,31 +52556,26 @@ function fileRecall(store, relPath) {
   priors.constraints.sort(byRank);
   priors.related.sort(byRank);
   const lines = [];
-  for (const p of priors.openProblems.slice(0, 3)) {
+  const shownProblems = priors.openProblems.slice(0, 3);
+  const shownConstraints = priors.constraints.slice(0, 2);
+  const shownRelated = priors.related.slice(0, 4);
+  for (const p of shownProblems) {
     const hasCause = store.outEdges(p.id, ["CAUSED_BY"]).some((e) => store.getNode(e.to)?.label === "RootCause");
     const causeCue = hasCause ? "" : ` \xB7 ${TAG_EXAMPLE.triageMint()} to diagnose its cause`;
     lines.push(
       recallLine(p, `${TAG_EXAMPLE.fix(p.id)} if you resolved it \xB7 ${TAG_EXAMPLE.prior(p.id)} to cite${causeCue}`)
     );
   }
-  for (const c of priors.constraints.slice(0, 2)) {
+  for (const c of shownConstraints) {
     lines.push(recallLine(c, `design tension \u2014 hold it, don't "fix" it \xB7 ${TAG_EXAMPLE.prior(c.id)} to cite`));
   }
-  for (const n of priors.related.slice(0, 4)) {
+  for (const n of shownRelated) {
     lines.push(recallLine(n, `cite with ${TAG_EXAMPLE.prior(n.id)}`));
   }
   const total = pool.length;
-  const headline = `${plural(total, "prior")} on ${relPath.split("/").slice(-2).join("/")}`;
-  const chainProblems = [...priors.openProblems, ...priors.resolvedProblems];
-  const scoreOf = new Map(ranked.map((r) => [r.id, r.score]));
-  const missing = /* @__PURE__ */ new Set();
-  for (const p of chainProblems) {
-    if (!scoreOf.has(p.id)) missing.add(p.id);
-    for (const e of store.outEdges(p.id, ["CAUSED_BY", "SOLVED_BY"])) if (!scoreOf.has(e.to)) missing.add(e.to);
-  }
-  for (const r of rankByRelevance(store, priors.file.id, [...missing])) scoreOf.set(r.id, r.score);
-  const chains = causalChains(store, chainProblems, (id) => scoreOf.get(id) ?? 0);
-  const card = signalCard(headline, ranked, chains, scoreOf) ?? { headline, items: [] };
+  const shown = [...shownProblems, ...shownConstraints, ...shownRelated].map(deliveredPrior);
+  const headline = `${plural(shown.length, "prior")} on ${relPath.split("/").slice(-2).join("/")}`;
+  const card = deliveredCard(store, headline, shown) ?? { headline, items: [] };
   return {
     context: `errata \u2014 ${total} prior(s) recorded on this file (act only if relevant):
 ${lines.join("\n")}
@@ -52975,30 +52964,28 @@ function buildWebUi(deps) {
       return c.json({});
     }
     const sid = String(body2["session_id"] ?? "");
-    const prompt = typeof body2["prompt"] === "string" ? body2["prompt"] : "";
     const hookEvent = String(body2["hook_event_name"] ?? "UserPromptSubmit");
-    if (sid && recallCardEnabled() && (hookEvent === "UserPromptSubmit" || hookEvent === "SessionStart")) {
-      const since = Date.now();
+    const atPrompt = hookEvent === "UserPromptSubmit" || hookEvent === "SessionStart";
+    if (sid && recallCardEnabled() && atPrompt) {
       setImmediate(() => {
         try {
           rememberOpenCount(sid, openProblemCount(deps.store));
         } catch {
         }
-        if (!prompt.trim()) return;
-        promptRecallCard(deps.store, prompt).then((card) => {
-          if (card) rememberCard(sid, card, Date.now(), since);
-        }).catch(() => {
-        });
       });
     }
     const block = readContextFileWithHash(deps.paths.root);
     const decision = decideContextInject({
-      event: String(body2["hook_event_name"] ?? "UserPromptSubmit"),
+      event: hookEvent,
       source: String(body2["source"] ?? ""),
-      sessionId: String(body2["session_id"] ?? ""),
+      sessionId: sid,
       block,
       lastInjectedHash
     });
+    if (sid && block && recallCardEnabled() && (decision || atPrompt)) {
+      const card = readContextCard(deps.paths.root, block.hash);
+      if (card) rememberCard(sid, card);
+    }
     if (!decision) return c.json({});
     return c.json({
       hookSpecificOutput: {
@@ -72038,27 +72025,27 @@ __export(witness_ledger_exports, {
   summarizeWitnessLedger: () => summarizeWitnessLedger,
   witnessLedgerPath: () => witnessLedgerPath
 });
-import { appendFileSync as appendFileSync3, existsSync as existsSync24, readFileSync as readFileSync26, writeFileSync as writeFileSync19 } from "node:fs";
-import { join as join32 } from "node:path";
+import { appendFileSync as appendFileSync3, existsSync as existsSync25, readFileSync as readFileSync27, writeFileSync as writeFileSync20 } from "node:fs";
+import { join as join33 } from "node:path";
 function witnessLedgerPath(configDir) {
-  return join32(configDir, "witness-ledger.jsonl");
+  return join33(configDir, "witness-ledger.jsonl");
 }
 function appendWitnessLedger(configDir, entry) {
   const path2 = witnessLedgerPath(configDir);
   try {
     appendFileSync3(path2, JSON.stringify(entry) + "\n");
-    const lines = readFileSync26(path2, "utf8").split("\n").filter(Boolean);
+    const lines = readFileSync27(path2, "utf8").split("\n").filter(Boolean);
     if (lines.length > LEDGER_MAX_LINES) {
-      writeFileSync19(path2, lines.slice(-Math.floor(LEDGER_MAX_LINES / 2)).join("\n") + "\n");
+      writeFileSync20(path2, lines.slice(-Math.floor(LEDGER_MAX_LINES / 2)).join("\n") + "\n");
     }
   } catch {
   }
 }
 function readWitnessLedger(configDir) {
   const path2 = witnessLedgerPath(configDir);
-  if (!existsSync24(path2)) return [];
+  if (!existsSync25(path2)) return [];
   try {
-    return readFileSync26(path2, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter((e) => typeof e.ts === "number" && typeof e.channel === "string");
+    return readFileSync27(path2, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter((e) => typeof e.ts === "number" && typeof e.channel === "string");
   } catch {
     return [];
   }
@@ -72497,12 +72484,12 @@ var init_report_render = __esm({
 
 // src/cli.ts
 init_src6();
-import { closeSync as closeSync2, existsSync as existsSync35, openSync as openSync2, readFileSync as readFileSync36, renameSync as renameSync4, statSync as statSync10 } from "node:fs";
-import { join as join43, resolve as pathResolve2 } from "node:path";
+import { closeSync as closeSync2, existsSync as existsSync36, openSync as openSync2, readFileSync as readFileSync37, renameSync as renameSync4, statSync as statSync10 } from "node:fs";
+import { join as join44, resolve as pathResolve2 } from "node:path";
 import { spawn as spawn5 } from "node:child_process";
 
 // src/daemon.ts
-import { existsSync as existsSync26, writeFileSync as writeFileSync22 } from "node:fs";
+import { existsSync as existsSync27, writeFileSync as writeFileSync23 } from "node:fs";
 
 // ../../node_modules/.pnpm/@hono+node-server@1.19.11_hono@4.12.8/node_modules/@hono/node-server/dist/index.mjs
 import { createServer as createServerHTTP } from "http";
@@ -73082,13 +73069,13 @@ init_config();
 
 // src/engine.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync25, statSync as statSync8, appendFileSync as appendFileSync4, readdirSync as readdirSync10, renameSync as renameSync3, readFileSync as readFileSync28, writeFileSync as writeFileSync21 } from "node:fs";
-import { basename as basename7, join as join34, relative as relative6, sep as sep4 } from "node:path";
+import { existsSync as existsSync26, statSync as statSync8, appendFileSync as appendFileSync4, readdirSync as readdirSync10, renameSync as renameSync3, readFileSync as readFileSync29, writeFileSync as writeFileSync22 } from "node:fs";
+import { basename as basename7, join as join35, relative as relative6, sep as sep4 } from "node:path";
 
 // src/source-watcher.ts
 import { EventEmitter as EventEmitter2 } from "node:events";
 import { statSync as statSync5, watch as watch2 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 
 // ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -74821,7 +74808,7 @@ var NativeSourceWatcher = class extends EventEmitter2 {
     }
     try {
       const h = watch2(target, { recursive: isDir, persistent: true }, (event, name2) => {
-        const path2 = isDir ? name2 ? join19(target, name2.toString()) : null : target;
+        const path2 = isDir ? name2 ? join20(target, name2.toString()) : null : target;
         if (!path2) return;
         this.emit("raw", event, path2, { watchedPath: target });
         if (!this.ignored(path2)) this.schedule(path2, event === "rename");
@@ -75121,13 +75108,14 @@ async function chat(req) {
 // src/engine.ts
 init_src11();
 init_src6();
+init_recall_signal();
 init_src8();
 init_review2();
 
 // src/turn.ts
 init_checkout_root();
-import { closeSync, existsSync as existsSync16, fstatSync, openSync, readdirSync as readdirSync6, readSync, realpathSync, statSync as statSync6 } from "node:fs";
-import { basename as basename5, delimiter, dirname as dirname10, join as join20, normalize as normalize3 } from "node:path";
+import { closeSync, existsSync as existsSync17, fstatSync, openSync, readdirSync as readdirSync6, readSync, realpathSync, statSync as statSync6 } from "node:fs";
+import { basename as basename5, delimiter, dirname as dirname10, join as join21, normalize as normalize3 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 import { createHash as createHash16 } from "node:crypto";
 function completeJsonlPrefix(buf) {
@@ -75515,11 +75503,11 @@ function turnsSince(turns, mark) {
   return at >= 0 ? turns.slice(at + 1) : turns;
 }
 function claudeProjectDir(cwd, home = homedir4()) {
-  return join20(home, ".claude", "projects", cwd.replace(/[\\/:.]/g, "-"));
+  return join21(home, ".claude", "projects", cwd.replace(/[\\/:.]/g, "-"));
 }
 function recentTranscripts(cwd, opts = {}) {
   const dir = claudeProjectDir(cwd, opts.home ?? homedir4());
-  if (!existsSync16(dir)) return [];
+  if (!existsSync17(dir)) return [];
   let names;
   try {
     names = readdirSync6(dir);
@@ -75530,7 +75518,7 @@ function recentTranscripts(cwd, opts = {}) {
   const refs = [];
   for (const name2 of names) {
     if (!name2.endsWith(".jsonl")) continue;
-    const path2 = join20(dir, name2);
+    const path2 = join21(dir, name2);
     let mtimeMs;
     try {
       mtimeMs = statSync6(path2).mtimeMs;
@@ -75545,8 +75533,8 @@ function recentTranscripts(cwd, opts = {}) {
 }
 function subagentTranscripts(mainTranscriptPath, sessionId) {
   if (!mainTranscriptPath || !sessionId) return [];
-  const dir = join20(dirname10(mainTranscriptPath), sessionId, "subagents");
-  if (!existsSync16(dir)) return [];
+  const dir = join21(dirname10(mainTranscriptPath), sessionId, "subagents");
+  if (!existsSync17(dir)) return [];
   let names;
   try {
     names = readdirSync6(dir);
@@ -75556,7 +75544,7 @@ function subagentTranscripts(mainTranscriptPath, sessionId) {
   const refs = [];
   for (const name2 of names) {
     if (!name2.endsWith(".jsonl")) continue;
-    const path2 = join20(dir, name2);
+    const path2 = join21(dir, name2);
     let mtimeMs;
     try {
       mtimeMs = statSync6(path2).mtimeMs;
@@ -75575,8 +75563,8 @@ function splitPathList(value, sep5 = delimiter) {
 function codexSessionRoots(env2 = process.env, home = homedir4()) {
   const roots = /* @__PURE__ */ new Set();
   for (const d of splitPathList(env2["ERRATA_CODEX_SESSIONS_DIRS"])) roots.add(d);
-  if (env2["CODEX_HOME"]) roots.add(join20(env2["CODEX_HOME"], "sessions"));
-  roots.add(join20(home, ".codex", "sessions"));
+  if (env2["CODEX_HOME"]) roots.add(join21(env2["CODEX_HOME"], "sessions"));
+  roots.add(join21(home, ".codex", "sessions"));
   return [...roots];
 }
 function readCodexRolloutIdentity(path2) {
@@ -75630,7 +75618,7 @@ function codexRolloutsForCwd(cwd, opts = {}) {
   const owner = checkoutRootOf(cwd);
   const owners = /* @__PURE__ */ new Map();
   for (const root of codexSessionRoots(opts.env, opts.home)) {
-    if (!existsSync16(root)) {
+    if (!existsSync17(root)) {
       codexRolloutActivity.delete(root);
       continue;
     }
@@ -75648,7 +75636,7 @@ function codexRolloutsForCwd(cwd, opts = {}) {
         continue;
       }
       for (const name2 of names) {
-        const full = join20(dir, name2);
+        const full = join21(dir, name2);
         let st;
         try {
           st = statSync6(full);
@@ -75690,8 +75678,8 @@ function codexRolloutsForCwd(cwd, opts = {}) {
 function geminiSessionRoots(env2 = process.env, home = homedir4()) {
   const roots = /* @__PURE__ */ new Set();
   for (const d of splitPathList(env2["ERRATA_GEMINI_SESSIONS_DIRS"])) roots.add(d);
-  if (env2["GEMINI_CLI_HOME"]) roots.add(join20(env2["GEMINI_CLI_HOME"], ".gemini", "tmp"));
-  roots.add(join20(home, ".gemini", "tmp"));
+  if (env2["GEMINI_CLI_HOME"]) roots.add(join21(env2["GEMINI_CLI_HOME"], ".gemini", "tmp"));
+  roots.add(join21(home, ".gemini", "tmp"));
   return [...roots];
 }
 function geminiProjectHash(cwd) {
@@ -75731,7 +75719,7 @@ function geminiTranscriptsForCwd(cwd, opts = {}) {
   const hashes = geminiHashesFor(cwd);
   const out2 = [];
   for (const root of geminiSessionRoots(opts.env, opts.home)) {
-    if (!existsSync16(root)) continue;
+    if (!existsSync17(root)) continue;
     let slugs;
     try {
       slugs = readdirSync6(root);
@@ -75739,7 +75727,7 @@ function geminiTranscriptsForCwd(cwd, opts = {}) {
       continue;
     }
     for (const slug2 of slugs) {
-      const chats = join20(root, slug2, "chats");
+      const chats = join21(root, slug2, "chats");
       let names;
       try {
         names = readdirSync6(chats);
@@ -75748,7 +75736,7 @@ function geminiTranscriptsForCwd(cwd, opts = {}) {
       }
       for (const name2 of names) {
         if (!name2.startsWith("session-") || !name2.endsWith(".jsonl")) continue;
-        const full = join20(chats, name2);
+        const full = join21(chats, name2);
         let st;
         try {
           st = statSync6(full);
@@ -75768,8 +75756,8 @@ function geminiTranscriptsForCwd(cwd, opts = {}) {
 function opencodeSessionRoots(env2 = process.env, home = homedir4()) {
   const roots = /* @__PURE__ */ new Set();
   for (const d of splitPathList(env2["ERRATA_OPENCODE_SESSIONS_DIRS"])) roots.add(d);
-  if (env2["XDG_DATA_HOME"]) roots.add(join20(env2["XDG_DATA_HOME"], "opencode", "errata"));
-  roots.add(join20(home, ".local", "share", "opencode", "errata"));
+  if (env2["XDG_DATA_HOME"]) roots.add(join21(env2["XDG_DATA_HOME"], "opencode", "errata"));
+  roots.add(join21(home, ".local", "share", "opencode", "errata"));
   return [...roots];
 }
 function readOpencodeTranscriptDirectory(path2) {
@@ -75802,7 +75790,7 @@ function opencodeTranscriptsForCwd(cwd, opts = {}) {
   }
   const out2 = [];
   for (const root of opencodeSessionRoots(opts.env, opts.home)) {
-    if (!existsSync16(root)) continue;
+    if (!existsSync17(root)) continue;
     let names;
     try {
       names = readdirSync6(root);
@@ -75811,7 +75799,7 @@ function opencodeTranscriptsForCwd(cwd, opts = {}) {
     }
     for (const name2 of names) {
       if (!name2.endsWith(".jsonl")) continue;
-      const full = join20(root, name2);
+      const full = join21(root, name2);
       let st;
       try {
         st = statSync6(full);
@@ -75834,7 +75822,7 @@ init_src2();
 init_agent_signals();
 init_tool_index();
 init_src5();
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "node:fs";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync13 } from "node:fs";
 var NEG = /n['']t|\b(?:not|never|no|none|neither|nor|unrelated|irrelevant|would|might|could|if)\b/i;
 var CITE_GROUP_RE = /\(((?:[^()\n]|\([^()\n]*\)){1,200})\)/g;
 var HANDLE_RE = /\[([a-z0-9][\w-]{0,80})\]|((?:pat|sol|drc|dcause|dfix|dprob|prob|claim|err)_[0-9a-f]{6,})/gi;
@@ -76523,13 +76511,13 @@ function writePrimingHandles(path2, nodes, now = Date.now()) {
       entries.sort((a, b) => (b[1].seenAt ?? 0) - (a[1].seenAt ?? 0));
       entries.length = HANDLE_MAP_MAX;
     }
-    writeFileSync12(path2, JSON.stringify(Object.fromEntries(entries)));
+    writeFileSync13(path2, JSON.stringify(Object.fromEntries(entries)));
   } catch {
   }
 }
 function readPrimingHandles(path2) {
   try {
-    return JSON.parse(readFileSync14(path2, "utf8"));
+    return JSON.parse(readFileSync15(path2, "utf8"));
   } catch {
     return {};
   }
@@ -77004,8 +76992,8 @@ ${conversation}` }]
 // src/constraint-backfill.ts
 init_src5();
 init_src2();
-import { existsSync as existsSync17, readFileSync as readFileSync15, readdirSync as readdirSync7, writeFileSync as writeFileSync13 } from "node:fs";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync16, readdirSync as readdirSync7, writeFileSync as writeFileSync14 } from "node:fs";
+import { join as join22 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 var BACKFILL_VERSION = 1;
 var EMPTY = {
@@ -77019,13 +77007,13 @@ var EMPTY = {
   recoverable: 0
 };
 function markerPath(configDir) {
-  return join21(configDir, "constraint-backfill.json");
+  return join22(configDir, "constraint-backfill.json");
 }
 function alreadyDone(configDir) {
   const p = markerPath(configDir);
-  if (!existsSync17(p)) return false;
+  if (!existsSync18(p)) return false;
   try {
-    const raw2 = JSON.parse(readFileSync15(p, "utf8"));
+    const raw2 = JSON.parse(readFileSync16(p, "utf8"));
     return raw2?.version === BACKFILL_VERSION;
   } catch {
     return false;
@@ -77035,7 +77023,7 @@ function replay(root) {
   const statements = /* @__PURE__ */ new Set();
   const citedByFix = /* @__PURE__ */ new Set();
   const dir = claudeProjectDir(root, homedir5());
-  if (!existsSync17(dir)) return { statements, citedByFix };
+  if (!existsSync18(dir)) return { statements, citedByFix };
   let names;
   try {
     names = readdirSync7(dir).filter((n) => n.endsWith(".jsonl"));
@@ -77045,7 +77033,7 @@ function replay(root) {
   for (const f of names) {
     let lines;
     try {
-      lines = readFileSync15(join21(dir, f), "utf8").split("\n");
+      lines = readFileSync16(join22(dir, f), "utf8").split("\n");
     } catch {
       continue;
     }
@@ -77159,7 +77147,7 @@ function backfillConstraintKind(store, opts) {
     }
   });
   try {
-    writeFileSync13(
+    writeFileSync14(
       markerPath(opts.configDir),
       JSON.stringify({ version: BACKFILL_VERSION, at: opts.now, ...report, cloudTwins: report.cloudTwins.length }, null, 2),
       "utf8"
@@ -77172,8 +77160,8 @@ function backfillConstraintKind(store, opts) {
 // src/edge-repair.ts
 init_src();
 init_src5();
-import { existsSync as existsSync18, readFileSync as readFileSync16, writeFileSync as writeFileSync14 } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync19, readFileSync as readFileSync17, writeFileSync as writeFileSync15 } from "node:fs";
+import { join as join23 } from "node:path";
 function citeEdgeId(from, type, to) {
   return `edge_${digest({ from, type, to })}`.slice(0, 24);
 }
@@ -77188,13 +77176,13 @@ var EMPTY2 = {
   byType: {}
 };
 function markerPath2(configDir) {
-  return join22(configDir, "edge-repair.json");
+  return join23(configDir, "edge-repair.json");
 }
 function alreadyDone2(configDir) {
   const p = markerPath2(configDir);
-  if (!existsSync18(p)) return false;
+  if (!existsSync19(p)) return false;
   try {
-    return JSON.parse(readFileSync16(p, "utf8"))?.version === EDGE_REPAIR_VERSION;
+    return JSON.parse(readFileSync17(p, "utf8"))?.version === EDGE_REPAIR_VERSION;
   } catch {
     return false;
   }
@@ -77243,7 +77231,7 @@ function repairInvalidEdges(store, opts) {
   });
   store.pruneEdgeRejections(opts.now - REJECTION_RETENTION_MS);
   try {
-    writeFileSync14(
+    writeFileSync15(
       markerPath2(opts.configDir),
       JSON.stringify({ version: EDGE_REPAIR_VERSION, at: opts.now, ...report }, null, 2),
       "utf8"
@@ -77257,8 +77245,8 @@ function repairInvalidEdges(store, opts) {
 init_reconcile();
 
 // src/pass-ledger.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync19, readFileSync as readFileSync17, writeFileSync as writeFileSync15 } from "node:fs";
-import { join as join23 } from "node:path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync20, readFileSync as readFileSync18, writeFileSync as writeFileSync16 } from "node:fs";
+import { join as join24 } from "node:path";
 
 // src/isolate-census.ts
 var live2 = 0;
@@ -77281,7 +77269,7 @@ var PER_KIND_MAX = 100;
 var TRIM_EVERY = 50;
 var appendsSinceTrim = /* @__PURE__ */ new Map();
 function passLedgerPath(configDir) {
-  return join23(configDir, "pass-ledger.jsonl");
+  return join24(configDir, "pass-ledger.jsonl");
 }
 function appendPassLedger(configDir, kind, durationMs, counts) {
   const path2 = passLedgerPath(configDir);
@@ -77310,7 +77298,7 @@ function appendPassLedger(configDir, kind, durationMs, counts) {
       return;
     }
     appendsSinceTrim.set(path2, 0);
-    const lines = readFileSync17(path2, "utf8").split("\n").filter(Boolean);
+    const lines = readFileSync18(path2, "utf8").split("\n").filter(Boolean);
     const keptByKind = /* @__PURE__ */ new Map();
     const kept = [];
     for (let i2 = lines.length - 1; i2 >= 0; i2--) {
@@ -77326,16 +77314,16 @@ function appendPassLedger(configDir, kind, durationMs, counts) {
       kept.push(lines[i2]);
     }
     if (kept.length < lines.length) {
-      writeFileSync15(path2, kept.reverse().join("\n") + "\n");
+      writeFileSync16(path2, kept.reverse().join("\n") + "\n");
     }
   } catch {
   }
 }
 function readPassLedger(configDir) {
   const path2 = passLedgerPath(configDir);
-  if (!existsSync19(path2)) return [];
+  if (!existsSync20(path2)) return [];
   try {
-    return readFileSync17(path2, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter(
+    return readFileSync18(path2, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter(
       (e) => typeof e?.ts === "number" && typeof e?.kind === "string" && typeof e?.durationMs === "number"
     ).map((e) => ({ ...e, counts: e.counts ?? {} }));
   } catch {
@@ -77707,11 +77695,11 @@ init_outbox();
 init_src10();
 init_src();
 init_src2();
-import { readFileSync as readFileSync18 } from "node:fs";
-import { join as join24 } from "node:path";
+import { readFileSync as readFileSync19 } from "node:fs";
+import { join as join25 } from "node:path";
 function loadClaimIgnorePatterns(workspaceRoot) {
   try {
-    return readFileSync18(join24(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
+    return readFileSync19(join25(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
   } catch {
     return [];
   }
@@ -78089,9 +78077,9 @@ async function pullCloudTriage(shared, cloud, profile, limit = 50) {
 // src/retrieval-stack.ts
 init_src();
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync20, readFileSync as readFileSync19, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync21, readFileSync as readFileSync20, statSync as statSync7 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 var RETRIEVAL_STACK_CAP = 24;
 var MANIFEST_SCAN_CAP = 400;
 var RUNTIME_TOKENS = /* @__PURE__ */ new Set([
@@ -78381,51 +78369,51 @@ function mavenGroupIsSelfDisclosing(name2, selfTokens) {
 function loadRegistryPolicy(root, env2 = process.env, repoLocator) {
   const read2 = (p) => {
     try {
-      return readFileSync19(p, "utf8");
+      return readFileSync20(p, "utf8");
     } catch {
       return null;
     }
   };
   const texts = (...paths) => paths.map(read2).filter((t) => t !== null);
   const home = homedir6();
-  const npm = parseNpmrcPolicy(texts(join25(root, ".npmrc"), join25(home, ".npmrc")));
+  const npm = parseNpmrcPolicy(texts(join26(root, ".npmrc"), join26(home, ".npmrc")));
   const blocked = /* @__PURE__ */ new Set();
   if (!npm.defaultPublic) blocked.add("npm");
   if (pypiIndexIsPrivate(
     texts(
-      join25(root, "pip.conf"),
-      join25(root, "pip.ini"),
-      join25(root, "pyproject.toml"),
-      join25(root, "requirements.txt"),
-      join25(home, ".pip", "pip.conf"),
-      join25(home, ".config", "pip", "pip.conf"),
-      join25(env2["APPDATA"] ?? home, "pip", "pip.ini")
+      join26(root, "pip.conf"),
+      join26(root, "pip.ini"),
+      join26(root, "pyproject.toml"),
+      join26(root, "requirements.txt"),
+      join26(home, ".pip", "pip.conf"),
+      join26(home, ".config", "pip", "pip.conf"),
+      join26(env2["APPDATA"] ?? home, "pip", "pip.ini")
     )
   )) {
     blocked.add("pypi");
   }
   if (cargoRegistryIsPrivate(
     texts(
-      join25(root, ".cargo", "config.toml"),
-      join25(root, ".cargo", "config"),
-      join25(home, ".cargo", "config.toml"),
-      join25(home, ".cargo", "config")
+      join26(root, ".cargo", "config.toml"),
+      join26(root, ".cargo", "config"),
+      join26(home, ".cargo", "config.toml"),
+      join26(home, ".cargo", "config")
     )
   )) {
     blocked.add("cargo");
   }
   if (nugetSourcesArePrivate(
     texts(
-      join25(root, "NuGet.config"),
-      join25(root, "nuget.config"),
-      join25(root, "NuGet.Config"),
-      join25(env2["APPDATA"] ?? home, "NuGet", "NuGet.Config"),
-      join25(home, ".nuget", "NuGet", "NuGet.Config")
+      join26(root, "NuGet.config"),
+      join26(root, "nuget.config"),
+      join26(root, "NuGet.Config"),
+      join26(env2["APPDATA"] ?? home, "NuGet", "NuGet.Config"),
+      join26(home, ".nuget", "NuGet", "NuGet.Config")
     )
   )) {
     blocked.add("nuget");
   }
-  const goEnvFile = env2["GOENV"] ?? join25(env2["APPDATA"] ?? join25(home, ".config"), "go", "env");
+  const goEnvFile = env2["GOENV"] ?? join26(env2["APPDATA"] ?? join26(home, ".config"), "go", "env");
   const goEnvText = read2(goEnvFile) ?? "";
   const fromFile = ["GOPRIVATE", "GONOSUMDB", "GONOSUMCHECK"].map(
     (k) => new RegExp(`^${k}=(.*)$`, "m").exec(goEnvText)?.[1]
@@ -78436,10 +78424,10 @@ function loadRegistryPolicy(root, env2 = process.env, repoLocator) {
     env2["GONOSUMCHECK"],
     ...fromFile
   ]);
-  const gemfiles = texts(join25(root, "Gemfile"));
+  const gemfiles = texts(join26(root, "Gemfile"));
   if (gemSourceIsPrivate(gemfiles)) blocked.add("gem");
   if (mavenReposArePrivate(
-    texts(join25(root, "pom.xml"), join25(home, ".m2", "settings.xml"))
+    texts(join26(root, "pom.xml"), join26(home, ".m2", "settings.xml"))
   )) {
     blocked.add("maven");
   }
@@ -78606,8 +78594,8 @@ function readDirectDependencies(root) {
   const familiesSeen = /* @__PURE__ */ new Set();
   for (const c of LOCKFILES) {
     if (familiesSeen.has(c.family)) continue;
-    const p = join25(root, c.file);
-    if (!existsSync20(p)) continue;
+    const p = join26(root, c.file);
+    if (!existsSync21(p)) continue;
     try {
       const s = statSync7(p);
       stamps.push(`${c.file}:${s.mtimeMs}:${s.size}`);
@@ -78627,7 +78615,7 @@ function readDirectDependencies(root) {
   const direct = [];
   for (const { c, path: path2 } of found) {
     try {
-      direct.push(...c.parse(readFileSync19(path2, "utf8")).direct ?? []);
+      direct.push(...c.parse(readFileSync20(path2, "utf8")).direct ?? []);
     } catch {
     }
   }
@@ -78670,14 +78658,14 @@ function manifestPaths(root) {
     "project.godot"
   ];
   return {
-    paths: ROOT_MANIFESTS.filter((f) => existsSync20(join25(root, f))),
+    paths: ROOT_MANIFESTS.filter((f) => existsSync21(join26(root, f))),
     tracked: false,
     truncated: false
   };
 }
 var WORKSPACE_MARKERS = ["pnpm-workspace.yaml", "lerna.json", "go.work", "settings.gradle", "settings.gradle.kts"];
 function rootDeclaresWorkspace(root, texts) {
-  if (WORKSPACE_MARKERS.some((f) => existsSync20(join25(root, f)))) return true;
+  if (WORKSPACE_MARKERS.some((f) => existsSync21(join26(root, f)))) return true;
   return /"workspaces"\s*:/.test(texts.get("package.json") ?? "") || /<modules>/.test(texts.get("pom.xml") ?? "") || /^\s*\[workspace\]/m.test(texts.get("Cargo.toml") ?? "");
 }
 var EMPTY_SCAN = { deps: [], self: [], complete: true };
@@ -78691,11 +78679,11 @@ function scanManifests(root) {
   const texts = /* @__PURE__ */ new Map();
   const stamps = [];
   for (const rel of paths) {
-    const abs = join25(root, rel);
+    const abs = join26(root, rel);
     try {
       const s = statSync7(abs);
       stamps.push(`${rel}:${s.mtimeMs}:${s.size}`);
-      texts.set(rel, readFileSync19(abs, "utf8"));
+      texts.set(rel, readFileSync20(abs, "utf8"));
     } catch {
     }
   }
@@ -78724,22 +78712,22 @@ function readManifestDependencies(root) {
 }
 
 // src/git-sensor.ts
-import { existsSync as existsSync21, readFileSync as readFileSync20, watch as fsWatch } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync21, watch as fsWatch } from "node:fs";
+import { join as join27 } from "node:path";
 function readFirstLine(path2) {
   try {
-    return readFileSync20(path2, "utf8").split(/\r?\n/, 1)[0].trim();
+    return readFileSync21(path2, "utf8").split(/\r?\n/, 1)[0].trim();
   } catch {
     return null;
   }
 }
 function readGitRefState(gitDir) {
-  const head2 = readFirstLine(join26(gitDir, "HEAD"));
+  const head2 = readFirstLine(join27(gitDir, "HEAD"));
   const m = head2 ? /^ref:\s*refs\/heads\/(.+)$/.exec(head2) : null;
   const branch = m ? m[1] : null;
   let sha2 = null;
   if (branch) {
-    sha2 = readFirstLine(join26(gitDir, "refs", "heads", branch));
+    sha2 = readFirstLine(join27(gitDir, "refs", "heads", branch));
     if (!sha2) sha2 = shaFromPackedRefs(gitDir, `refs/heads/${branch}`);
   } else if (head2 && /^[0-9a-f]{7,40}$/i.test(head2)) {
     sha2 = head2;
@@ -78747,13 +78735,13 @@ function readGitRefState(gitDir) {
   return {
     branch,
     sha: sha2,
-    mergeHeadExists: existsSync21(join26(gitDir, "MERGE_HEAD")),
-    origHeadExists: existsSync21(join26(gitDir, "ORIG_HEAD"))
+    mergeHeadExists: existsSync22(join27(gitDir, "MERGE_HEAD")),
+    origHeadExists: existsSync22(join27(gitDir, "ORIG_HEAD"))
   };
 }
 function shaFromPackedRefs(gitDir, ref) {
   try {
-    for (const line of readFileSync20(join26(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
+    for (const line of readFileSync21(join27(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
       const [sha2, name2] = line.split(/\s+/);
       if (name2 === ref && sha2) return sha2;
     }
@@ -78787,7 +78775,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
   const settle = () => {
     if (timer) clearTimeout(timer);
     timer = setTimeout(() => {
-      if (existsSync21(join26(gitDir, "index.lock"))) {
+      if (existsSync22(join27(gitDir, "index.lock"))) {
         settle();
         return;
       }
@@ -78798,7 +78786,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
     }, debounceMs);
   };
   for (const sub of ["HEAD", "logs/HEAD", "MERGE_HEAD", "ORIG_HEAD"]) {
-    const p = join26(gitDir, sub);
+    const p = join27(gitDir, sub);
     try {
       watchers.push(fsWatch(p, settle));
     } catch {
@@ -79022,8 +79010,8 @@ var TelemetryRecorder = class {
 };
 
 // src/file-activity.ts
-import { readFileSync as readFileSync22 } from "node:fs";
-import { join as join28 } from "node:path";
+import { readFileSync as readFileSync23 } from "node:fs";
+import { join as join29 } from "node:path";
 import { createHash as createHash17 } from "node:crypto";
 
 // ../../packages/privacy/src/patterns/credentials.ts
@@ -79775,8 +79763,8 @@ init_git_remote();
 // src/history-bundle.ts
 init_src();
 import { execFile as execFile2 } from "node:child_process";
-import { readFileSync as readFileSync21 } from "node:fs";
-import { join as join27 } from "node:path";
+import { readFileSync as readFileSync22 } from "node:fs";
+import { join as join28 } from "node:path";
 var DEFAULT_MAX_TOKENS = 6e3;
 var FILE_LIST_CAP = 60;
 var DIFF_FILE_CAP = 40;
@@ -79811,7 +79799,7 @@ function pathAllowedByFloor(path2) {
 function loadRepoIgnore(root, extraPatterns = []) {
   let source = "";
   try {
-    source = readFileSync21(join27(root, ".errataignore"), "utf8");
+    source = readFileSync22(join28(root, ".errataignore"), "utf8");
   } catch {
     source = "";
   }
@@ -80104,7 +80092,7 @@ function readActivityBranch(root) {
   try {
     const gitDir = resolveGitDir(root);
     if (!gitDir) return null;
-    const head2 = readFileSync22(join28(gitDir, "HEAD"), "utf8").trim();
+    const head2 = readFileSync23(join29(gitDir, "HEAD"), "utf8").trim();
     const branch = head2.startsWith("ref: refs/heads/") ? head2.slice(16) : /^[a-f0-9]{40,64}$/i.test(head2) ? "HEAD" : null;
     return branch && branch.length <= 256 && !/[\x00-\x1f\x7f]/.test(branch) ? branch : null;
   } catch {
@@ -80261,21 +80249,21 @@ var FileActivityReporter = class {
 
 // src/skills.ts
 import {
-  existsSync as existsSync22,
+  existsSync as existsSync23,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync23,
+  readFileSync as readFileSync24,
   readdirSync as readdirSync8,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync16
+  writeFileSync as writeFileSync17
 } from "node:fs";
-import { basename as basename6, join as join29 } from "node:path";
+import { basename as basename6, join as join30 } from "node:path";
 function skillFileName(id) {
   return `${id.replace(/[^A-Za-z0-9_.-]/g, "_")}.md`;
 }
 function readSkillManifest(manifestPath) {
-  if (!existsSync22(manifestPath)) return [];
+  if (!existsSync23(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync23(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync24(manifestPath, "utf8"));
     return (parsed.skills ?? []).map((s) => ({
       title: s.title ?? "",
       layer: s.layer ?? "technique",
@@ -80299,7 +80287,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
   for (const s of res.skills) {
     const fileName = skillFileName(s.id);
     keep.add(fileName);
-    writeFileSync16(join29(paths.skillsDir, fileName), s.markdown, "utf8");
+    writeFileSync17(join30(paths.skillsDir, fileName), s.markdown, "utf8");
     rows.push({
       id: s.id,
       title: s.title,
@@ -80312,7 +80300,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
     const fileName = skillFileName(p.id);
     if (keep.has(fileName)) continue;
     keep.add(fileName);
-    writeFileSync16(join29(paths.skillsDir, fileName), p.markdown, "utf8");
+    writeFileSync17(join30(paths.skillsDir, fileName), p.markdown, "utf8");
     rows.push({
       id: p.id,
       title: p.title,
@@ -80326,13 +80314,13 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
     if (!f.endsWith(".md")) continue;
     if (keep.has(basename6(f))) continue;
     try {
-      unlinkSync2(join29(paths.skillsDir, f));
+      unlinkSync2(join30(paths.skillsDir, f));
       pruned++;
     } catch {
     }
   }
   rows.sort((a, b) => a.id.localeCompare(b.id));
-  writeFileSync16(
+  writeFileSync17(
     paths.skillsManifest,
     JSON.stringify({ generatedAt: Date.now(), skills: rows }, null, 2),
     "utf8"
@@ -80344,22 +80332,22 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
 init_src2();
 import {
   cpSync,
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   lstatSync,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync24,
+  readFileSync as readFileSync25,
   readdirSync as readdirSync9,
   rmSync as rmSync3,
   symlinkSync,
-  writeFileSync as writeFileSync17
+  writeFileSync as writeFileSync18
 } from "node:fs";
-import { join as join30 } from "node:path";
+import { join as join31 } from "node:path";
 var SKILL_NS = "errata-";
 var HARNESS_SKILL_DIRS = [
-  { configDir: ".claude", skillsDir: join30(".claude", "skills") },
+  { configDir: ".claude", skillsDir: join31(".claude", "skills") },
   // Cursor adopted the standard; its exact project dir is still moving — kept
   // best-effort and gated on `.cursor/` presence so we never create it blind.
-  { configDir: ".cursor", skillsDir: join30(".cursor", "skills") }
+  { configDir: ".cursor", skillsDir: join31(".cursor", "skills") }
 ];
 function skillSlug(title, id) {
   const base = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || id.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "skill";
@@ -80404,12 +80392,12 @@ function skillCiteHandle(s) {
   return priorHandle({ id: s.id, description: s.title });
 }
 function reconcileNamespaced(dir, keep) {
-  if (!existsSync23(dir)) return 0;
+  if (!existsSync24(dir)) return 0;
   let pruned = 0;
   for (const name2 of readdirSync9(dir)) {
     if (!name2.startsWith(SKILL_NS) || keep.has(name2)) continue;
     try {
-      rmSync3(join30(dir, name2), { recursive: true, force: true });
+      rmSync3(join31(dir, name2), { recursive: true, force: true });
       pruned++;
     } catch {
     }
@@ -80418,7 +80406,7 @@ function reconcileNamespaced(dir, keep) {
 }
 function linkOrCopy(linkPath, target) {
   try {
-    if (existsSync23(linkPath) || safeLstat(linkPath)) rmSync3(linkPath, { recursive: true, force: true });
+    if (existsSync24(linkPath) || safeLstat(linkPath)) rmSync3(linkPath, { recursive: true, force: true });
   } catch {
   }
   try {
@@ -80439,7 +80427,7 @@ function safeLstat(p) {
   }
 }
 function emitAndProjectSkills(root, skills) {
-  const agentsSkillsDir = join30(root, ".agents", "skills");
+  const agentsSkillsDir = join31(root, ".agents", "skills");
   mkdirSync8(agentsSkillsDir, { recursive: true });
   const slugs = [];
   const keep = /* @__PURE__ */ new Set();
@@ -80447,7 +80435,7 @@ function emitAndProjectSkills(root, skills) {
   for (const s of skills) {
     let body2;
     try {
-      body2 = readFileSync24(s.bodyPath, "utf8");
+      body2 = readFileSync25(s.bodyPath, "utf8");
     } catch {
       continue;
     }
@@ -80456,9 +80444,9 @@ function emitAndProjectSkills(root, skills) {
     keep.add(slug2);
     slugs.push(slug2);
     const description = deriveDescription(s.title, s.layer, body2);
-    mkdirSync8(join30(agentsSkillsDir, slug2), { recursive: true });
-    writeFileSync17(
-      join30(agentsSkillsDir, slug2, "SKILL.md"),
+    mkdirSync8(join31(agentsSkillsDir, slug2), { recursive: true });
+    writeFileSync18(
+      join31(agentsSkillsDir, slug2, "SKILL.md"),
       renderSkillMd(slug2, description, body2, skillCiteHandle(s)),
       "utf8"
     );
@@ -80467,11 +80455,11 @@ function emitAndProjectSkills(root, skills) {
   reconcileNamespaced(agentsSkillsDir, keep);
   let projected = 0;
   for (const h of HARNESS_SKILL_DIRS) {
-    if (!existsSync23(join30(root, h.configDir))) continue;
-    const dir = join30(root, h.skillsDir);
+    if (!existsSync24(join31(root, h.configDir))) continue;
+    const dir = join31(root, h.skillsDir);
     mkdirSync8(dir, { recursive: true });
     for (const slug2 of slugs) {
-      linkOrCopy(join30(dir, slug2), join30(agentsSkillsDir, slug2));
+      linkOrCopy(join31(dir, slug2), join31(agentsSkillsDir, slug2));
       projected++;
     }
     reconcileNamespaced(dir, keep);
@@ -80480,15 +80468,15 @@ function emitAndProjectSkills(root, skills) {
   return { slugs, emitted, projected };
 }
 function emitInputsFromManifest(erretaDir, manifestPath) {
-  if (!existsSync23(manifestPath)) return [];
+  if (!existsSync24(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync24(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync25(manifestPath, "utf8"));
     return (parsed.skills ?? []).filter((s) => Boolean(s.id && s.file)).map((s) => ({
       id: s.id,
       title: s.title ?? s.id,
       layer: s.layer ?? "technique",
       confidence: s.confidence ?? 0,
-      bodyPath: join30(erretaDir, s.file)
+      bodyPath: join31(erretaDir, s.file)
     }));
   } catch {
     return [];
@@ -80502,17 +80490,17 @@ var GITIGNORE_LINES = [
   ".cursor/skills/errata-*/"
 ];
 function ensureSkillGitignore(root) {
-  const path2 = join30(root, ".gitignore");
+  const path2 = join31(root, ".gitignore");
   let current = "";
   try {
-    current = existsSync23(path2) ? readFileSync24(path2, "utf8") : "";
+    current = existsSync24(path2) ? readFileSync25(path2, "utf8") : "";
   } catch {
     return;
   }
   if (current.includes(GITIGNORE_MARK)) return;
   const prefix = current.length > 0 && !current.endsWith("\n") ? "\n" : "";
   try {
-    writeFileSync17(path2, `${current}${prefix}
+    writeFileSync18(path2, `${current}${prefix}
 ${GITIGNORE_LINES.join("\n")}
 `, "utf8");
   } catch {
@@ -80608,18 +80596,18 @@ init_paths();
 init_profile2();
 
 // src/witness-queue.ts
-import { readFileSync as readFileSync25, renameSync as renameSync2, writeFileSync as writeFileSync18 } from "node:fs";
-import { dirname as dirname11, join as join31 } from "node:path";
+import { readFileSync as readFileSync26, renameSync as renameSync2, writeFileSync as writeFileSync19 } from "node:fs";
+import { dirname as dirname11, join as join32 } from "node:path";
 var WITNESS_QUEUE_CAP = 500;
 var WITNESS_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
 var WITNESS_MAX_ATTEMPTS = 5;
 function witnessQueuePath(workspaceConfigDir) {
-  return join31(workspaceConfigDir, "witness-queue.json");
+  return join32(workspaceConfigDir, "witness-queue.json");
 }
 function loadWitnessQueueWithLosses(path2) {
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync25(path2, "utf8"));
+    raw2 = JSON.parse(readFileSync26(path2, "utf8"));
   } catch (err2) {
     const absent = err2?.code === "ENOENT";
     return { queue: [], fileUnreadable: !absent, malformedEntries: 0 };
@@ -80632,8 +80620,8 @@ function loadWitnessQueueWithLosses(path2) {
 }
 function saveWitnessQueue(path2, queue) {
   try {
-    const tmp = join31(dirname11(path2), `.${Date.now()}.witness-queue.tmp`);
-    writeFileSync18(tmp, JSON.stringify(queue), "utf8");
+    const tmp = join32(dirname11(path2), `.${Date.now()}.witness-queue.tmp`);
+    writeFileSync19(tmp, JSON.stringify(queue), "utf8");
     renameSync2(tmp, path2);
   } catch {
   }
@@ -80940,8 +80928,8 @@ function maybeFlushDigests() {
 
 // src/liveness-watch.ts
 init_src5();
-import { readFileSync as readFileSync27, writeFileSync as writeFileSync20 } from "node:fs";
-import { join as join33 } from "node:path";
+import { readFileSync as readFileSync28, writeFileSync as writeFileSync21 } from "node:fs";
+import { join as join34 } from "node:path";
 
 // src/loop-lag.ts
 var HEARTBEAT_MS = 500;
@@ -81072,11 +81060,11 @@ function watchCensusLine(c = watchCensus(), now = Date.now()) {
 var LIVENESS_WATCH_INTERVAL_MS = 60 * 60 * 1e3;
 var ALARM_RENOTIFY_MS = 24 * 60 * 60 * 1e3;
 function alarmStatePath(configDir) {
-  return join33(configDir, "liveness-alarms.json");
+  return join34(configDir, "liveness-alarms.json");
 }
 function loadAlarmState(configDir) {
   try {
-    const raw2 = JSON.parse(readFileSync27(alarmStatePath(configDir), "utf8"));
+    const raw2 = JSON.parse(readFileSync28(alarmStatePath(configDir), "utf8"));
     return new Map(Object.entries(raw2).filter((e) => typeof e[1] === "number"));
   } catch {
     return /* @__PURE__ */ new Map();
@@ -81084,7 +81072,7 @@ function loadAlarmState(configDir) {
 }
 function saveAlarmState(configDir, state) {
   try {
-    writeFileSync20(alarmStatePath(configDir), JSON.stringify(Object.fromEntries(state)));
+    writeFileSync21(alarmStatePath(configDir), JSON.stringify(Object.fromEntries(state)));
   } catch {
   }
 }
@@ -81253,7 +81241,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.14-dev.3228" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.14-dev.3236" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -81265,7 +81253,7 @@ var CODEX_SWEEP_LOOKBACK_MS = 10 * 6e4;
 function appendIdentityAudit(path2, record2, line) {
   if (!record2.accepted && record2.score <= 0) return;
   try {
-    if (existsSync25(path2) && statSync8(path2).size >= IDENTITY_AUDIT_MAX_BYTES) {
+    if (existsSync26(path2) && statSync8(path2).size >= IDENTITY_AUDIT_MAX_BYTES) {
       renameSync3(path2, `${path2}.1`);
     }
     appendFileSync4(path2, line);
@@ -81275,7 +81263,7 @@ function appendIdentityAudit(path2, record2, line) {
 var yieldToLoop = () => new Promise((r) => setImmediate(r));
 function loadTurnCursors(path2) {
   try {
-    const raw2 = JSON.parse(readFileSync28(path2, "utf8"));
+    const raw2 = JSON.parse(readFileSync29(path2, "utf8"));
     return new Map(
       Object.entries(raw2).map(([k, v]) => [k, typeof v === "string" ? v : String(v?.uuid ?? "")])
     );
@@ -81285,7 +81273,7 @@ function loadTurnCursors(path2) {
 }
 function loadTurnOffsets(path2) {
   try {
-    const raw2 = JSON.parse(readFileSync28(path2, "utf8"));
+    const raw2 = JSON.parse(readFileSync29(path2, "utf8"));
     const out2 = /* @__PURE__ */ new Map();
     for (const [k, v] of Object.entries(raw2)) {
       const off = typeof v === "object" && v !== null ? v.offset : void 0;
@@ -81301,7 +81289,7 @@ function saveTurnCursors(path2, cursors, offsets) {
     const merged = {};
     for (const [k, uuid3] of cursors) merged[k] = { uuid: uuid3, offset: offsets.get(k) ?? 0 };
     for (const [k, offset] of offsets) if (!merged[k]) merged[k] = { uuid: "", offset };
-    writeFileSync21(path2, JSON.stringify(merged), "utf8");
+    writeFileSync22(path2, JSON.stringify(merged), "utf8");
   } catch {
   }
 }
@@ -81323,7 +81311,7 @@ function gitSourceWatchTargets(root) {
         ["-C", root, "ls-files", "--others", "--ignored", "--exclude-standard", "--directory", "-z"],
         { encoding: "utf8", maxBuffer: 256 * 1024 * 1024, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] }
       );
-      ignoredDirs = igOut.split("\0").filter(Boolean).map((d) => d.replace(/\/+$/, "")).filter((d) => !IGNORED_PATH.test(join34(root, d) + sep4));
+      ignoredDirs = igOut.split("\0").filter(Boolean).map((d) => d.replace(/\/+$/, "")).filter((d) => !IGNORED_PATH.test(join35(root, d) + sep4));
     } catch {
     }
     const hasIgnoredChild = (dir) => ignoredDirs.some((ig) => ig.startsWith(dir + "/"));
@@ -81335,19 +81323,19 @@ function gitSourceWatchTargets(root) {
         if (!f.startsWith(prefix)) continue;
         const rest2 = f.slice(prefix.length);
         if (rest2.includes("/")) children.add(dir === "" ? rest2.slice(0, rest2.indexOf("/")) : dir + "/" + rest2.slice(0, rest2.indexOf("/")));
-        else targets.add(join34(root, f));
+        else targets.add(join35(root, f));
       }
       for (const c of children) {
-        if (IGNORED_PATH.test(join34(root, c) + sep4)) continue;
+        if (IGNORED_PATH.test(join35(root, c) + sep4)) continue;
         if (hasIgnoredChild(c)) addUnder(c);
-        else targets.add(join34(root, c));
+        else targets.add(join35(root, c));
       }
     };
     addUnder("");
     if (targets.size > 0) return [...targets];
   } catch {
   }
-  return readdirSync10(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !IGNORED_PATH.test(join34(root, String(e.name)) + sep4)).map((e) => join34(root, String(e.name)));
+  return readdirSync10(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !IGNORED_PATH.test(join35(root, String(e.name)) + sep4)).map((e) => join35(root, String(e.name)));
 }
 function createWorkspaceEngine(opts) {
   const paths = workspacePaths(opts.workspaceRoot);
@@ -81553,7 +81541,7 @@ function createWorkspaceEngine(opts) {
       const srcPaths = diff.changedPaths.filter((p) => /\.(ts|tsx|js|jsx|mjs|cjs|py)$/i.test(p));
       let episodeId2;
       if (srcPaths.length > 0) {
-        const abs = srcPaths.map((p) => join34(opts.workspaceRoot, p));
+        const abs = srcPaths.map((p) => join35(opts.workspaceRoot, p));
         try {
           const r = await runReindexPass(
             `git-reindex:${profile.name} (${abs.length} files)`,
@@ -81589,8 +81577,8 @@ function createWorkspaceEngine(opts) {
         `[errata] git: ${ev.kind} ${ev.newSha.slice(0, 7)} by ${meta3.authorName} \u2014 ${diff.changedPaths.length} file(s), ${diff.renames.length} rename(s)`
       );
     };
-    const gitDir = join34(opts.workspaceRoot, ".git");
-    if (existsSync25(gitDir)) {
+    const gitDir = join35(opts.workspaceRoot, ".git");
+    if (existsSync26(gitDir)) {
       stopGit = startGitSensor(gitDir, (ev) => {
         void handleGitEvent(ev).catch((err2) => {
           console.warn("[errata] git event handler failed:", err2);
@@ -81709,7 +81697,7 @@ function createWorkspaceEngine(opts) {
     const elicit = isEdgeElicitationEnabled();
     const snapOpts = {
       profile,
-      atCommit: readGitRefState(join34(opts.workspaceRoot, ".git")).sha ?? void 0,
+      atCommit: readGitRefState(join35(opts.workspaceRoot, ".git")).sha ?? void 0,
       reviewCount: pendingCount(paths),
       reviewUiUrl: opts.reviewUrl(),
       workingFile: workingFiles.mostRecent() ?? void 0,
@@ -81723,7 +81711,7 @@ function createWorkspaceEngine(opts) {
       );
       return null;
     }) : null;
-    if (snapOpts.atCommit !== (readGitRefState(join34(opts.workspaceRoot, ".git")).sha ?? void 0)) {
+    if (snapOpts.atCommit !== (readGitRefState(join35(opts.workspaceRoot, ".git")).sha ?? void 0)) {
       contextDirty = true;
       return;
     }
@@ -81776,10 +81764,16 @@ function createWorkspaceEngine(opts) {
       console.warn("[errata] render ledger failed:", err2.message?.slice(0, 120));
     }
     writeContextFile(opts.workspaceRoot, body2);
-    const target = join34(opts.workspaceRoot, "AGENTS.md");
+    try {
+      const written = readContextFileWithHash(opts.workspaceRoot);
+      if (written) writeContextCard(opts.workspaceRoot, written.hash, contextCard(store, snapshot));
+    } catch (err2) {
+      console.warn("[errata] context card failed:", err2.message?.slice(0, 120));
+    }
+    const target = join35(opts.workspaceRoot, "AGENTS.md");
     writeManagedBlock(target, { body: AGENTS_POINTER_BODY, stable: true, force: true });
     if (elicit) {
-      writePrimingHandles(join34(paths.configDir, "priming-handles.json"), [
+      writePrimingHandles(join35(paths.configDir, "priming-handles.json"), [
         ...snapshot.recentProblems.map((r) => r.node),
         // Resolved-band handles: the ✓ problem AND its Solution are citable
         // (a fix tag on an already-resolved problem no-ops idempotently; the
@@ -82121,7 +82115,7 @@ function createWorkspaceEngine(opts) {
       resultSummary: { exitCode: e.exitCode ?? 1, errorTokens: e.errorTokens }
     });
   };
-  const turnCursorPath = join34(paths.configDir, "turn-cursors.json");
+  const turnCursorPath = join35(paths.configDir, "turn-cursors.json");
   const lastTurnUuid = loadTurnCursors(turnCursorPath);
   const turnOffset = loadTurnOffsets(turnCursorPath);
   const readLosses = { parseFailures: 0, ioFailures: 0, bytesUnreachable: 0, sliceGuardHits: 0 };
@@ -82179,7 +82173,7 @@ function createWorkspaceEngine(opts) {
     let processedTurns = 0;
     const seqAtStart = store.currentIngestSeq();
     const elicit = isEdgeElicitationEnabled();
-    const handleMap = elicit ? readPrimingHandles(join34(paths.configDir, "priming-handles.json")) : {};
+    const handleMap = elicit ? readPrimingHandles(join35(paths.configDir, "priming-handles.json")) : {};
     const wsRoot = (opts.workspaceRoot ?? "").replace(/\\/g, "/");
     const toRel = (abs) => {
       const p = abs.replace(/\\/g, "/");
@@ -82476,10 +82470,10 @@ function createWorkspaceEngine(opts) {
                 let enclosing = {};
                 if (p.location?.line !== void 0) {
                   try {
-                    const headSha = readGitRefState(join34(opts.workspaceRoot, ".git")).sha ?? void 0;
+                    const headSha = readGitRefState(join35(opts.workspaceRoot, ".git")).sha ?? void 0;
                     enclosing = {
                       line: p.location.line,
-                      fileText: readFileSync28(join34(opts.workspaceRoot, anchorPath), "utf8"),
+                      fileText: readFileSync29(join35(opts.workspaceRoot, anchorPath), "utf8"),
                       ...headSha ? { headSha } : {}
                     };
                   } catch {
@@ -83278,7 +83272,7 @@ B: ${b}`,
     try {
       const inputs = emitInputsFromManifest(paths.configDir, paths.skillsManifest);
       emitAndProjectSkills(opts.workspaceRoot, inputs);
-      writePrimingHandles(join34(paths.configDir, "priming-handles.json"), skillHandleNodes(inputs));
+      writePrimingHandles(join35(paths.configDir, "priming-handles.json"), skillHandleNodes(inputs));
     } catch (err2) {
       console.warn("[skills] agent-skills projection failed (non-fatal):", err2 instanceof Error ? err2.message : err2);
     }
@@ -83585,7 +83579,7 @@ B: ${b}`,
         console.log(
           "[errata] sync skipped \u2014 cloud sync consent is off (enable with `errata consent sync on`)"
         );
-        const pending = existsSync25(paths.outbox) ? readdirSync10(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
+        const pending = existsSync26(paths.outbox) ? readdirSync10(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
         return { uploaded: 0, failed: 0, remaining: pending };
       }
       const onDisk = loadProfile(opts.workspaceRoot);
@@ -83593,7 +83587,7 @@ B: ${b}`,
         console.log(
           "[errata] sync held \u2014 this repo is already on errata in another workspace; run `errata link` to join it or create your own project"
         );
-        const pending = existsSync25(paths.outbox) ? readdirSync10(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
+        const pending = existsSync26(paths.outbox) ? readdirSync10(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
         return { uploaded: 0, failed: 0, remaining: pending };
       }
       try {
@@ -83686,7 +83680,7 @@ async function startDaemon(opts) {
     reviewUrl: () => webUiUrl + "/review"
   });
   const writeLockFile = (url2) => {
-    writeFileSync22(
+    writeFileSync23(
       engine.paths.daemonLock,
       JSON.stringify({ pid: process.pid, webUiUrl: url2, startedAt: Date.now() }),
       "utf8"
@@ -83729,7 +83723,7 @@ async function startDaemon(opts) {
       );
       await engine.stop();
       try {
-        if (existsSync26(engine.paths.daemonLock)) {
+        if (existsSync27(engine.paths.daemonLock)) {
         }
       } catch {
       }
@@ -83930,7 +83924,7 @@ function instanceReceiptSequence(n) {
 // src/multi.ts
 init_dist();
 init_src5();
-import { existsSync as existsSync32, readFileSync as readFileSync33, unlinkSync as unlinkSync3, writeFileSync as writeFileSync24 } from "node:fs";
+import { existsSync as existsSync33, readFileSync as readFileSync34, unlinkSync as unlinkSync3, writeFileSync as writeFileSync25 } from "node:fs";
 import { resolve as pathResolve } from "node:path";
 
 // src/principle-sync.ts
@@ -83959,8 +83953,8 @@ init_reconcile();
 
 // src/lockfile-auto.ts
 init_src();
-import { existsSync as existsSync27, readFileSync as readFileSync29 } from "node:fs";
-import { join as join35 } from "node:path";
+import { existsSync as existsSync28, readFileSync as readFileSync30 } from "node:fs";
+import { join as join36 } from "node:path";
 
 // src/package-index.ts
 init_src();
@@ -84109,11 +84103,11 @@ function runLockfilePass(opts) {
     { file: "package-lock.json", parse: parsePackageLockJson }
   ];
   for (const c of candidates) {
-    const p = join35(opts.root, c.file);
-    if (!existsSync27(p)) continue;
+    const p = join36(opts.root, c.file);
+    if (!existsSync28(p)) continue;
     let sbom;
     try {
-      sbom = c.parse(readFileSync29(p, "utf8"));
+      sbom = c.parse(readFileSync30(p, "utf8"));
     } catch {
       continue;
     }
@@ -84173,8 +84167,8 @@ function noveltyAgainst(node2, neighbors, opts = {}) {
 init_profile2();
 
 // src/public-symbols.ts
-import { readFileSync as readFileSync30, readdirSync as readdirSync11, existsSync as existsSync28 } from "node:fs";
-import { join as join36 } from "node:path";
+import { readFileSync as readFileSync31, readdirSync as readdirSync11, existsSync as existsSync29 } from "node:fs";
+import { join as join37 } from "node:path";
 var HEAD_BYTES = 8 * 1024;
 var INDEX_TTL_MS = 10 * 60 * 1e3;
 var MIN_SYMBOL_LEN = 4;
@@ -84207,20 +84201,20 @@ function bindingNames(clause) {
 function internalPackageNames(workspaceRoot) {
   const names = /* @__PURE__ */ new Set();
   const tryRead = (dir) => {
-    const pj = join36(dir, "package.json");
-    if (!existsSync28(pj)) return;
+    const pj = join37(dir, "package.json");
+    if (!existsSync29(pj)) return;
     try {
-      const name2 = JSON.parse(readFileSync30(pj, "utf8")).name;
+      const name2 = JSON.parse(readFileSync31(pj, "utf8")).name;
       if (typeof name2 === "string" && name2.length > 0) names.add(name2);
     } catch {
     }
   };
   tryRead(workspaceRoot);
   for (const group of ["packages", "apps"]) {
-    const groupDir = join36(workspaceRoot, group);
-    if (!existsSync28(groupDir)) continue;
+    const groupDir = join37(workspaceRoot, group);
+    if (!existsSync29(groupDir)) continue;
     try {
-      for (const entry of readdirSync11(groupDir)) tryRead(join36(groupDir, entry));
+      for (const entry of readdirSync11(groupDir)) tryRead(join37(groupDir, entry));
     } catch {
     }
   }
@@ -84239,7 +84233,7 @@ function publicSymbolIndex(store, workspaceRoot, deps = {}) {
   }
   const readHead = deps.readHead ?? ((absPath) => {
     try {
-      return readFileSync30(absPath, "utf8").slice(0, HEAD_BYTES);
+      return readFileSync31(absPath, "utf8").slice(0, HEAD_BYTES);
     } catch {
       return "";
     }
@@ -84259,7 +84253,7 @@ function publicSymbolIndex(store, workspaceRoot, deps = {}) {
   }
   const symbols = /* @__PURE__ */ new Set();
   for (const rel of files) {
-    const head2 = readHead(join36(workspaceRoot, rel));
+    const head2 = readHead(join37(workspaceRoot, rel));
     if (!head2) continue;
     for (const re of [NAMED_IMPORT_RE, REQUIRE_RE]) {
       re.lastIndex = 0;
@@ -85058,7 +85052,7 @@ function cloudTargetDrift(daemon, shell2) {
 }
 
 // src/lock.ts
-import { existsSync as existsSync29, readFileSync as readFileSync31 } from "node:fs";
+import { existsSync as existsSync30, readFileSync as readFileSync32 } from "node:fs";
 function daemonLockPayload(lock) {
   return JSON.stringify({
     pid: lock.pid,
@@ -85096,9 +85090,9 @@ function isProcessAlive(pid) {
   }
 }
 function readDaemonLock(lockPath) {
-  if (!existsSync29(lockPath)) return null;
+  if (!existsSync30(lockPath)) return null;
   try {
-    const lock = JSON.parse(readFileSync31(lockPath, "utf8"));
+    const lock = JSON.parse(readFileSync32(lockPath, "utf8"));
     return typeof lock.pid === "number" ? lock : null;
   } catch {
     return null;
@@ -85812,8 +85806,8 @@ async function syncHistoryRevisionPage(opts) {
 init_src7();
 init_src();
 import { execFile as execFile5 } from "node:child_process";
-import { readFileSync as readFileSync32 } from "node:fs";
-import { join as join37 } from "node:path";
+import { readFileSync as readFileSync33 } from "node:fs";
+import { join as join38 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 
 // src/history-walk.ts
@@ -86136,8 +86130,8 @@ function narrative(unit, group) {
 }
 function narrativeSources(unit, group) {
   if (!group || group.length === 0) return [{ commitSha: unit.sha, text: message(unit).trim() }].filter((s) => s.text.length > 0);
-  const members2 = group.filter((g) => g.groupSha === (unit.groupSha ?? unit.sha)).sort((a, b) => a.subIndex - b.subIndex);
-  const source = members2.length > 0 ? members2 : [...group].sort((a, b) => a.subIndex - b.subIndex);
+  const members = group.filter((g) => g.groupSha === (unit.groupSha ?? unit.sha)).sort((a, b) => a.subIndex - b.subIndex);
+  const source = members.length > 0 ? members : [...group].sort((a, b) => a.subIndex - b.subIndex);
   return source.map((member) => ({ commitSha: member.sha, text: message(member).trim() })).filter((s) => s.text.length > 0);
 }
 
@@ -86360,7 +86354,7 @@ async function defaultGit(root, args2) {
 function readIgnoreLines(root, profile) {
   let lines = [];
   try {
-    lines = readFileSync32(join37(root, ".errataignore"), "utf8").split("\n");
+    lines = readFileSync33(join38(root, ".errataignore"), "utf8").split("\n");
   } catch {
   }
   return [...lines, ...profile.ignoreExtra ?? []].map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
@@ -86790,8 +86784,8 @@ async function startHistoryStage(root, input, client, walk11 = {}) {
 init_cloud_auth();
 import { createHash as createHash19 } from "node:crypto";
 import { execFileSync as execFileSync5 } from "node:child_process";
-import { existsSync as existsSync30, writeFileSync as writeFileSync23 } from "node:fs";
-import { join as join38 } from "node:path";
+import { existsSync as existsSync31, writeFileSync as writeFileSync24 } from "node:fs";
+import { join as join39 } from "node:path";
 
 // src/device-poll.ts
 var THROTTLED_POLL_MIN_WAIT_MS = 11e3;
@@ -87249,9 +87243,9 @@ function applyLinkDecision(root, profile, config2, decision, now = Date.now) {
   delete nextProfile.projectLinkHold;
   let wroteIgnore = false;
   if (decision.writeIgnoreStarter !== false) {
-    const target = join38(root, ".errataignore");
-    if (!existsSync30(target)) {
-      writeFileSync23(target, IGNORE_STARTER, "utf8");
+    const target = join39(root, ".errataignore");
+    if (!existsSync31(target)) {
+      writeFileSync24(target, IGNORE_STARTER, "utf8");
       wroteIgnore = true;
     }
   }
@@ -87264,12 +87258,12 @@ init_registry();
 
 // src/adopt.ts
 init_git_remote();
-import { existsSync as existsSync31 } from "node:fs";
-import { dirname as dirname12, join as join39 } from "node:path";
+import { existsSync as existsSync32 } from "node:fs";
+import { dirname as dirname12, join as join40 } from "node:path";
 function findGitRoot(absPath) {
   let dir = absPath;
   for (let depth = 0; depth < 64; depth++) {
-    if (existsSync31(join39(dir, ".git"))) return dir;
+    if (existsSync32(join40(dir, ".git"))) return dir;
     const parent = dirname12(dir);
     if (parent === dir) return null;
     dir = parent;
@@ -87962,7 +87956,7 @@ async function startMultiDaemon(opts = {}) {
     records.push(rec);
     void ambientLinkAll();
     try {
-      writeFileSync24(
+      writeFileSync25(
         rec.engine.paths.daemonLock,
         daemonLockPayload({
           pid: process.pid,
@@ -88248,7 +88242,7 @@ async function startMultiDaemon(opts = {}) {
         lastActiveAt = Math.max(lastActiveAt, rec.engine.lastActivityAt());
       } catch {
       }
-      const reason = retireDecision({ exists: existsSync32(rec.root), lastActiveAt, now });
+      const reason = retireDecision({ exists: existsSync33(rec.root), lastActiveAt, now });
       if (reason) void retireWorkspace(rec, reason);
     }
   };
@@ -88319,7 +88313,7 @@ async function startMultiDaemon(opts = {}) {
   baseUrl = `http://127.0.0.1:${port}`;
   try {
     ensureDir(globalDir());
-    writeFileSync24(
+    writeFileSync25(
       lockPath,
       daemonLockPayload({ pid: process.pid, webUiUrl: baseUrl, processStartedAt: PROCESS_STARTED_AT, entry: SELF_ENTRY, version: DAEMON_VERSION }),
       "utf8"
@@ -88328,7 +88322,7 @@ async function startMultiDaemon(opts = {}) {
   }
   for (const r of records) {
     try {
-      writeFileSync24(
+      writeFileSync25(
         r.engine.paths.daemonLock,
         daemonLockPayload({
           pid: process.pid,
@@ -89300,7 +89294,7 @@ async function startMultiDaemon(opts = {}) {
       clearInterval(anchorPull);
       clearTimeout(codexWakeBoot);
       try {
-        const cur = readFileSync33(lockPath, "utf8");
+        const cur = readFileSync34(lockPath, "utf8");
         if (JSON.parse(cur).pid === process.pid) unlinkSync3(lockPath);
       } catch {
       }
@@ -89723,7 +89717,7 @@ import { spawnSync } from "node:child_process";
 
 // src/codex-runtime.ts
 import { readdirSync as readdirSync12, statSync as statSync9 } from "node:fs";
-import { join as join40 } from "node:path";
+import { join as join41 } from "node:path";
 function resolveCodexExecutable(options = {}) {
   const platform = options.platform ?? process.platform;
   const env2 = options.env ?? process.env;
@@ -89738,13 +89732,13 @@ function resolveCodexExecutable(options = {}) {
   };
   for (const dir of (env2["PATH"] ?? env2["Path"] ?? "").split(";")) {
     if (!dir.trim()) continue;
-    const path2 = join40(dir.trim().replace(/^"|"$/g, ""), "codex.exe");
+    const path2 = join41(dir.trim().replace(/^"|"$/g, ""), "codex.exe");
     if (fileTime(path2) !== null) return path2;
   }
   if (!env2["LOCALAPPDATA"]) return "codex";
-  const root = join40(env2["LOCALAPPDATA"], "OpenAI", "Codex", "bin");
+  const root = join41(env2["LOCALAPPDATA"], "OpenAI", "Codex", "bin");
   try {
-    const candidates = readdirSync12(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join40(root, entry.name, "codex.exe")).map((path2) => ({ path: path2, mtime: fileTime(path2) })).filter((candidate) => candidate.mtime !== null).sort((a, b) => b.mtime - a.mtime || a.path.localeCompare(b.path));
+    const candidates = readdirSync12(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join41(root, entry.name, "codex.exe")).map((path2) => ({ path: path2, mtime: fileTime(path2) })).filter((candidate) => candidate.mtime !== null).sort((a, b) => b.mtime - a.mtime || a.path.localeCompare(b.path));
     return candidates[0]?.path ?? "codex";
   } catch {
     return "codex";
@@ -89863,9 +89857,9 @@ import { spawn as spawn4 } from "node:child_process";
 import { createInterface } from "node:readline";
 
 // src/codex-hooks.ts
-import { existsSync as existsSync33, mkdirSync as mkdirSync9, readFileSync as readFileSync34, writeFileSync as writeFileSync25 } from "node:fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync9, readFileSync as readFileSync35, writeFileSync as writeFileSync26 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { join as join41 } from "node:path";
+import { join as join42 } from "node:path";
 
 // src/hook-commands.ts
 function hookCurlCommand(port, path2 = "/api/hook") {
@@ -89944,8 +89938,8 @@ try {
 
 // src/codex-hooks.ts
 var CODEX_HOOK_REVIEW_HELP = "Codex desktop: Settings > Hooks, select this project, expand each event and Trust the Errata hook. CLI users can use /hooks.";
-function hasCodexConfig(root, codexHome = process.env["CODEX_HOME"] || join41(homedir7(), ".codex")) {
-  return existsSync33(join41(root, ".codex")) || existsSync33(codexHome);
+function hasCodexConfig(root, codexHome = process.env["CODEX_HOME"] || join42(homedir7(), ".codex")) {
+  return existsSync34(join42(root, ".codex")) || existsSync34(codexHome);
 }
 function replaceCodexHooks(existing, block) {
   const begin = existing.indexOf(CODEX_HOOKS_BEGIN);
@@ -89961,14 +89955,14 @@ function replaceCodexHooks(existing, block) {
   return existing.trimEnd() + (existing.trim() ? "\n\n" : "") + block;
 }
 function writeCodexHooks(root, port, nodePath = process.execPath) {
-  const dir = join41(root, ".codex");
-  const file2 = join41(dir, "config.toml");
-  const relay = join41(dir, "hooks", "errata-relay.mjs");
+  const dir = join42(root, ".codex");
+  const file2 = join42(dir, "config.toml");
+  const relay = join42(dir, "hooks", "errata-relay.mjs");
   const block = buildCodexHooksToml(port, { nodePath, relayPath: relay });
-  const final = replaceCodexHooks(existsSync33(file2) ? readFileSync34(file2, "utf8") : "", block);
-  mkdirSync9(join41(dir, "hooks"), { recursive: true });
-  writeFileSync25(relay, CODEX_RELAY_SOURCE, "utf8");
-  writeFileSync25(file2, final, "utf8");
+  const final = replaceCodexHooks(existsSync34(file2) ? readFileSync35(file2, "utf8") : "", block);
+  mkdirSync9(join42(dir, "hooks"), { recursive: true });
+  writeFileSync26(relay, CODEX_RELAY_SOURCE, "utf8");
+  writeFileSync26(file2, final, "utf8");
   return file2;
 }
 
@@ -90135,9 +90129,9 @@ function consolidationGapMs(lastPassMs, policy) {
 }
 
 // src/claude-statusline.ts
-import { existsSync as existsSync34, mkdirSync as mkdirSync10, readFileSync as readFileSync35, writeFileSync as writeFileSync26 } from "node:fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync10, readFileSync as readFileSync36, writeFileSync as writeFileSync27 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname13, join as join42 } from "node:path";
+import { dirname as dirname13, join as join43 } from "node:path";
 var STATUSLINE_RELAY_SOURCE = String.raw`// errata-managed: regenerated by errata init / install-hooks claude
 import { readFileSync } from 'node:fs';
 
@@ -90170,8 +90164,8 @@ function removeProjectStatusLine(settings) {
   return true;
 }
 function userClaudeSettingsPath() {
-  const base = process.env["CLAUDE_CONFIG_DIR"] ?? join42(homedir8(), ".claude");
-  return join42(base, "settings.json");
+  const base = process.env["CLAUDE_CONFIG_DIR"] ?? join43(homedir8(), ".claude");
+  return join43(base, "settings.json");
 }
 function ensureUserStatusLine(opts) {
   const env2 = opts.env ?? process.env;
@@ -90179,9 +90173,9 @@ function ensureUserStatusLine(opts) {
   if (off === "0" || off === "off" || off === "false" || off === "no") return "disabled";
   const settingsPath = opts.userSettingsPath ?? userClaudeSettingsPath();
   let settings = {};
-  if (existsSync34(settingsPath)) {
+  if (existsSync35(settingsPath)) {
     try {
-      const parsed = JSON.parse(readFileSync35(settingsPath, "utf8"));
+      const parsed = JSON.parse(readFileSync36(settingsPath, "utf8"));
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return "unreadable";
       settings = parsed;
     } catch {
@@ -90189,16 +90183,16 @@ function ensureUserStatusLine(opts) {
     }
   }
   if (settings["statusLine"] !== void 0 && !isErrataStatusLine(settings["statusLine"])) return "kept-own";
-  const relay = join42(opts.relayDir, STATUSLINE_RELAY_FILE);
+  const relay = join43(opts.relayDir, STATUSLINE_RELAY_FILE);
   mkdirSync10(opts.relayDir, { recursive: true });
-  if (!existsSync34(relay) || readFileSync35(relay, "utf8") !== STATUSLINE_RELAY_SOURCE) {
-    writeFileSync26(relay, STATUSLINE_RELAY_SOURCE, "utf8");
+  if (!existsSync35(relay) || readFileSync36(relay, "utf8") !== STATUSLINE_RELAY_SOURCE) {
+    writeFileSync27(relay, STATUSLINE_RELAY_SOURCE, "utf8");
   }
   const next = buildStatusLine(opts.port, opts.nodePath ?? process.execPath, relay);
   if (JSON.stringify(settings["statusLine"]) === JSON.stringify(next)) return "unchanged";
   settings["statusLine"] = next;
   mkdirSync10(dirname13(settingsPath), { recursive: true });
-  writeFileSync26(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  writeFileSync27(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
   return "installed";
 }
 function describeStatusLineOutcome(outcome) {
@@ -90621,14 +90615,14 @@ async function cmdInit() {
   if (!skipHooks) {
     console.log("");
     console.log("installing harness hooks...");
-    const { existsSync: existsSync36 } = await import("node:fs");
-    const { join: join44 } = await import("node:path");
+    const { existsSync: existsSync37 } = await import("node:fs");
+    const { join: join45 } = await import("node:path");
     try {
       await installClaudeHooks(port);
     } catch (err2) {
       console.warn(`  \u26A0\uFE0F  Claude hook install failed: ${err2 instanceof Error ? err2.message : err2}`);
     }
-    if (existsSync36(join44(ROOT, ".cursor"))) {
+    if (existsSync37(join45(ROOT, ".cursor"))) {
       try {
         await installCursorMcpConfig();
       } catch (err2) {
@@ -90818,9 +90812,9 @@ async function cmdStatus() {
     console.log(`    stack:     ${profile.stack.join(", ") || "(none)"}`);
     console.log(`    languages: ${profile.languages.join(", ") || "(none)"}`);
   }
-  console.log(`  graph db:  ${existsSync35(paths.castalia) ? "yes" : "no"} (${paths.castalia})`);
-  console.log(`  event log: ${existsSync35(paths.eventLog) ? "yes" : "no"} (${paths.eventLog})`);
-  if (existsSync35(paths.castalia)) {
+  console.log(`  graph db:  ${existsSync36(paths.castalia) ? "yes" : "no"} (${paths.castalia})`);
+  console.log(`  event log: ${existsSync36(paths.eventLog) ? "yes" : "no"} (${paths.eventLog})`);
+  if (existsSync36(paths.castalia)) {
     try {
       const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src5(), src_exports2));
       const store = openGraphStore2({ path: paths.castalia });
@@ -91788,11 +91782,11 @@ async function cmdInstallationProfile(args2) {
 }
 async function cmdReview() {
   const paths = workspacePaths(ROOT);
-  if (!existsSync35(paths.reviewQueue)) {
+  if (!existsSync36(paths.reviewQueue)) {
     console.log("(review queue empty)");
     return;
   }
-  const queue = JSON.parse(readFileSync36(paths.reviewQueue, "utf8"));
+  const queue = JSON.parse(readFileSync37(paths.reviewQueue, "utf8"));
   if (queue.length === 0) {
     console.log("(review queue empty)");
     return;
@@ -92463,7 +92457,7 @@ async function gatherRepo(store, ws) {
   };
 }
 async function gatherReportData(generatedAt) {
-  const { existsSync: existsSync36 } = await import("node:fs");
+  const { existsSync: existsSync37 } = await import("node:fs");
   const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src5(), src_exports2));
   const cfg = loadConfig();
   const outbound = cfg.consent.sync ? "auto" : "off";
@@ -92471,7 +92465,7 @@ async function gatherReportData(generatedAt) {
   for (const ws of listWorkspaces()) {
     if (ws.missing) continue;
     const dbPath = workspacePaths(ws.path).castalia;
-    if (!existsSync36(dbPath)) continue;
+    if (!existsSync37(dbPath)) continue;
     let store = null;
     try {
       store = openGraphStore2({ path: dbPath });
@@ -92502,7 +92496,7 @@ async function gatherReportData(generatedAt) {
   };
 }
 async function cmdReport(args2) {
-  const { mkdirSync: mkdirSync11, writeFileSync: writeFileSync27 } = await import("node:fs");
+  const { mkdirSync: mkdirSync11, writeFileSync: writeFileSync28 } = await import("node:fs");
   const { renderReport: renderReport2 } = await Promise.resolve().then(() => (init_report_render(), report_render_exports));
   const includeFutureVerbs = args2.includes("--future-verbs");
   const now = /* @__PURE__ */ new Date();
@@ -92515,8 +92509,8 @@ async function cmdReport(args2) {
   const outDir = workspacePaths(ROOT).configDir;
   mkdirSync11(outDir, { recursive: true });
   const files = renderReport2(data, { includeFutureVerbs });
-  for (const f of files) writeFileSync27(join43(outDir, f.name), f.html, "utf8");
-  const indexPath = join43(outDir, "report.html");
+  for (const f of files) writeFileSync28(join44(outDir, f.name), f.html, "utf8");
+  const indexPath = join44(outDir, "report.html");
   console.log(`report \u2192 ${indexPath}`);
   console.log(
     `  ${data.repos.length} repo(s) \xB7 ${files.length} file(s) \xB7 ${data.rollup.nodes.toLocaleString("en-US")} nodes`
@@ -92636,24 +92630,24 @@ async function cmdInstallHooks(args2) {
   }
 }
 async function installOpencodePlugin(port) {
-  const { mkdirSync: mkdirSync11, existsSync: existsSync36, readFileSync: readFileSync37, writeFileSync: writeFileSync27 } = await import("node:fs");
-  const { join: join44 } = await import("node:path");
-  const dir = join44(ROOT, ".opencode", "plugin");
-  if (!existsSync36(dir)) mkdirSync11(dir, { recursive: true });
-  const file2 = join44(dir, "inerrata.js");
-  if (existsSync36(file2)) {
-    const head2 = readFileSync37(file2, "utf8").split("\n")[0] ?? "";
+  const { mkdirSync: mkdirSync11, existsSync: existsSync37, readFileSync: readFileSync38, writeFileSync: writeFileSync28 } = await import("node:fs");
+  const { join: join45 } = await import("node:path");
+  const dir = join45(ROOT, ".opencode", "plugin");
+  if (!existsSync37(dir)) mkdirSync11(dir, { recursive: true });
+  const file2 = join45(dir, "inerrata.js");
+  if (existsSync37(file2)) {
+    const head2 = readFileSync38(file2, "utf8").split("\n")[0] ?? "";
     if (head2.trim() !== OPENCODE_PLUGIN_MARKER) {
       console.error(`refusing to overwrite ${file2}: not an errata-managed plugin (line 1 lacks the marker)`);
       process.exit(2);
     }
   }
-  writeFileSync27(file2, buildOpencodePluginSource(port, { version: DAEMON_VERSION }), "utf8");
-  const cfgFile = join44(ROOT, "opencode.json");
+  writeFileSync28(file2, buildOpencodePluginSource(port, { version: DAEMON_VERSION }), "utf8");
+  const cfgFile = join45(ROOT, "opencode.json");
   let cfg = { $schema: "https://opencode.ai/config.json" };
-  if (existsSync36(cfgFile)) {
+  if (existsSync37(cfgFile)) {
     try {
-      cfg = JSON.parse(readFileSync37(cfgFile, "utf8"));
+      cfg = JSON.parse(readFileSync38(cfgFile, "utf8"));
     } catch {
       console.error(`refusing to touch invalid JSON at ${cfgFile} \u2014 fix it and re-run`);
       process.exit(2);
@@ -92664,7 +92658,7 @@ async function installOpencodePlugin(port) {
   if (!hadErrata) {
     const inv = errataMcpInvocation();
     cfg.mcp["errata"] = { type: "local", command: [inv.command, ...inv.args] };
-    writeFileSync27(cfgFile, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+    writeFileSync28(cfgFile, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   }
   console.log(`installed OpenCode plugin \u2192 ${file2}`);
   if (hadErrata) console.log(`  mcp.errata already present in ${cfgFile} \u2014 left untouched`);
@@ -92691,15 +92685,15 @@ function ensureStatusLine(port) {
   }
 }
 async function installClaudeHooks(port) {
-  const { mkdirSync: mkdirSync11, existsSync: existsSync36, readFileSync: readFileSync37, writeFileSync: writeFileSync27 } = await import("node:fs");
-  const { join: join44 } = await import("node:path");
-  const dir = join44(ROOT, ".claude");
-  if (!existsSync36(dir)) mkdirSync11(dir, { recursive: true });
-  const file2 = join44(dir, "settings.json");
+  const { mkdirSync: mkdirSync11, existsSync: existsSync37, readFileSync: readFileSync38, writeFileSync: writeFileSync28 } = await import("node:fs");
+  const { join: join45 } = await import("node:path");
+  const dir = join45(ROOT, ".claude");
+  if (!existsSync37(dir)) mkdirSync11(dir, { recursive: true });
+  const file2 = join45(dir, "settings.json");
   let settings = {};
-  if (existsSync36(file2)) {
+  if (existsSync37(file2)) {
     try {
-      settings = JSON.parse(readFileSync37(file2, "utf8"));
+      settings = JSON.parse(readFileSync38(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -92747,11 +92741,11 @@ async function installClaudeHooks(port) {
     list.push({ hooks: [{ type: "command", command: injectCmd }] });
   }
   removeProjectStatusLine(settings);
-  writeFileSync27(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  writeFileSync28(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
   console.log(`installed Claude Code hooks \u2192 ${file2}`);
   console.log(`  ${ensureStatusLine(port)}`);
   await installClaudeMcpConfig();
-  const claudeMd = join44(ROOT, "CLAUDE.md");
+  const claudeMd = join45(ROOT, "CLAUDE.md");
   const recall = writeManagedBlock(claudeMd, { body: RECALL_FIRST_BLOCK });
   if (recall.kind === "collision") {
     console.warn(
@@ -92763,15 +92757,15 @@ async function installClaudeHooks(port) {
   console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
 }
 async function installClaudeMcpConfig() {
-  const { mkdirSync: mkdirSync11, existsSync: existsSync36, readFileSync: readFileSync37, writeFileSync: writeFileSync27 } = await import("node:fs");
-  const { join: join44, dirname: dirname14 } = await import("node:path");
-  const file2 = join44(ROOT, ".mcp.json");
+  const { mkdirSync: mkdirSync11, existsSync: existsSync37, readFileSync: readFileSync38, writeFileSync: writeFileSync28 } = await import("node:fs");
+  const { join: join45, dirname: dirname14 } = await import("node:path");
+  const file2 = join45(ROOT, ".mcp.json");
   const dir = dirname14(file2);
-  if (!existsSync36(dir)) mkdirSync11(dir, { recursive: true });
+  if (!existsSync37(dir)) mkdirSync11(dir, { recursive: true });
   let cfg = {};
-  if (existsSync36(file2)) {
+  if (existsSync37(file2)) {
     try {
-      cfg = JSON.parse(readFileSync37(file2, "utf8"));
+      cfg = JSON.parse(readFileSync38(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -92779,21 +92773,21 @@ async function installClaudeMcpConfig() {
   }
   cfg.mcpServers ??= {};
   cfg.mcpServers["errata"] = errataMcpInvocation();
-  writeFileSync27(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  writeFileSync28(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   console.log(`installed Claude Code MCP server config \u2192 ${file2}`);
   console.log(`  Claude Code will spawn \`errata mcp\` on workspace open.`);
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses / show / similar`);
 }
 async function installCursorMcpConfig() {
-  const { mkdirSync: mkdirSync11, existsSync: existsSync36, readFileSync: readFileSync37, writeFileSync: writeFileSync27 } = await import("node:fs");
-  const { join: join44 } = await import("node:path");
-  const dir = join44(ROOT, ".cursor");
-  if (!existsSync36(dir)) mkdirSync11(dir, { recursive: true });
-  const file2 = join44(dir, "mcp.json");
+  const { mkdirSync: mkdirSync11, existsSync: existsSync37, readFileSync: readFileSync38, writeFileSync: writeFileSync28 } = await import("node:fs");
+  const { join: join45 } = await import("node:path");
+  const dir = join45(ROOT, ".cursor");
+  if (!existsSync37(dir)) mkdirSync11(dir, { recursive: true });
+  const file2 = join45(dir, "mcp.json");
   let cfg = {};
-  if (existsSync36(file2)) {
+  if (existsSync37(file2)) {
     try {
-      cfg = JSON.parse(readFileSync37(file2, "utf8"));
+      cfg = JSON.parse(readFileSync38(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -92801,7 +92795,7 @@ async function installCursorMcpConfig() {
   }
   cfg.mcpServers ??= {};
   cfg.mcpServers["errata"] = errataMcpInvocation();
-  writeFileSync27(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  writeFileSync28(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   console.log(`installed Cursor MCP server config \u2192 ${file2}`);
   console.log(`  Cursor will spawn \`errata mcp\` on workspace open.`);
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses`);
@@ -92812,7 +92806,7 @@ async function installCodexHooks(port) {
   const gitRoot = nearestGitRoot(process.cwd());
   const hookRoot = gitRoot && mainCheckoutOfWorktree(gitRoot) ? gitRoot : ROOT;
   const file2 = writeCodexHooks(hookRoot, port);
-  const instructions = writeManagedBlock(join43(hookRoot, "AGENTS.md"), {
+  const instructions = writeManagedBlock(join44(hookRoot, "AGENTS.md"), {
     body: AGENTS_POINTER_BODY,
     stable: true
   });
@@ -93216,9 +93210,9 @@ async function cmdDash(args2) {
       await yieldToLoop2();
       try {
         const items = selectDurableMemory(handle2.sharedStore, r.engine.profile, {
-          atCommit: readGitRefState(join43(r.root, ".git")).sha ?? void 0
+          atCommit: readGitRefState(join44(r.root, ".git")).sha ?? void 0
         });
-        const res = bleedRules(join43(r.root, ".claude", "rules"), items);
+        const res = bleedRules(join44(r.root, ".claude", "rules"), items);
         if (res.written || res.pruned) {
           console.log(
             `[rules:${r.entry.name}] ${res.written} collective principle(s) \u2192 .claude/rules` + (res.pruned ? `, ${res.pruned} pruned` : "")