@inerrata-corporation/errata 2.0.23-dev.4900 → 2.0.23-dev.4901

package/errata.mjs

@@ -19589,7 +19589,7 @@ var init_lineage_integrity = __esm({
 });
 
 // ../../packages/math/src/constants.ts
-var SURPRISE_MOMENTUM, SURPRISE_LEARNING_RATE, SURPRISE_LEARNING_RATE_SCALING, TIER_HALFLIFE_MULTIPLIER, HIT_RATE_SCALING_ALPHA, BASE_HALF_LIFE_SEQ, MOMENTUM_GATE_FLOOR, EVIDENCE_HALFLIFE_SEQ, EVIDENCE_ACCEPTED_HALFLIFE_MULT, EVIDENCE_DECAY_FLOOR, CORROBORATION_WEIGHT, SURPRISE_RECENCY_LAMBDA_SEQ, NEMORI_SOFT_WRITE_MIN_COSINE, NEMORI_SOFT_WRITE_MAX_COSINE, NEMORI_DEDUP_COSINE, NEMORI_SOFT_ALPHA_MIN, NEMORI_SOFT_ALPHA_MAX, NEMORI_HIGH_SURPRISE_THRESHOLD, NEMORI_PREDICTION_FLOOR, REVIEW_SURPRISE_THRESHOLD, REVIEW_HITS_THRESHOLD;
+var SURPRISE_MOMENTUM, SURPRISE_LEARNING_RATE, SURPRISE_LEARNING_RATE_SCALING, TIER_HALFLIFE_MULTIPLIER, HIT_RATE_SCALING_ALPHA, BASE_HALF_LIFE_SEQ, MOMENTUM_GATE_FLOOR, EVIDENCE_HALFLIFE_SEQ, EVIDENCE_ACCEPTED_HALFLIFE_MULT, EVIDENCE_DECAY_FLOOR, CORROBORATION_WEIGHT, SURPRISE_RECENCY_LAMBDA_SEQ, NEMORI_SOFT_WRITE_MIN_COSINE, NEMORI_SOFT_WRITE_MAX_COSINE, NEMORI_DEDUP_COSINE, NEMORI_SOFT_ALPHA_MIN, NEMORI_SOFT_ALPHA_MAX, NEMORI_HIGH_SURPRISE_THRESHOLD, REVIEW_SURPRISE_THRESHOLD, REVIEW_HITS_THRESHOLD;
 var init_constants = __esm({
   "../../packages/math/src/constants.ts"() {
     "use strict";
@@ -19615,7 +19615,6 @@ var init_constants = __esm({
     NEMORI_SOFT_ALPHA_MIN = 0.6;
     NEMORI_SOFT_ALPHA_MAX = 1;
     NEMORI_HIGH_SURPRISE_THRESHOLD = 0.2;
-    NEMORI_PREDICTION_FLOOR = 0.5;
     REVIEW_SURPRISE_THRESHOLD = 3;
     REVIEW_HITS_THRESHOLD = 5;
   }
@@ -23839,49 +23838,231 @@ var init_problem_package_link = __esm({
   }
 });
 
+// ../../packages/embedding/src/static.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname4, join as join3 } from "node:path";
+import { fileURLToPath } from "node:url";
+function decodeStaticAsset(bytes) {
+  const buf = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (buf.toString("ascii", 0, 8) !== ASSET_MAGIC) throw new Error("static model: bad magic");
+  const headerLength = buf.readUInt32LE(8);
+  const header = JSON.parse(buf.toString("utf8", 12, 12 + headerLength));
+  if (header.format !== 1) throw new Error(`static model: unsupported format ${String(header.format)}`);
+  const lead2 = 12 + headerLength;
+  const scalesAt = lead2 + (4 - lead2 % 4) % 4;
+  const scales = new Float32Array(buf.buffer.slice(buf.byteOffset + scalesAt, buf.byteOffset + scalesAt + 4 * header.rows));
+  const weightsAt = scalesAt + 4 * header.rows;
+  const weights = new Int8Array(buf.buffer.slice(buf.byteOffset + weightsAt, buf.byteOffset + weightsAt + header.rows * header.dim));
+  if (weights.length !== header.rows * header.dim) throw new Error("static model: truncated weights");
+  return staticModel(header, scales, weights);
+}
+function staticModel(header, scales, weights) {
+  const vocab = /* @__PURE__ */ new Map();
+  header.vocab.forEach((token, id) => vocab.set(token, id));
+  const unkId = vocab.get(header.unkToken);
+  const { dim, rows, prefix, maxCharsPerWord } = header;
+  function wordpiece(word) {
+    const chars = Array.from(word);
+    if (chars.length > maxCharsPerWord) return unkId === void 0 ? [] : [unkId];
+    const ids = [];
+    let start2 = 0;
+    while (start2 < chars.length) {
+      let end = chars.length;
+      let found;
+      while (start2 < end) {
+        const piece = (start2 > 0 ? prefix : "") + chars.slice(start2, end).join("");
+        found = vocab.get(piece);
+        if (found !== void 0) break;
+        end--;
+      }
+      if (found === void 0) return unkId === void 0 ? [] : [unkId];
+      ids.push(found);
+      start2 = end;
+    }
+    return ids;
+  }
+  function tokenize4(text) {
+    return preTokenize(normalize2(text)).flatMap(wordpiece);
+  }
+  function embed2(text) {
+    const sum = new Float64Array(dim);
+    let used = 0;
+    for (const id of tokenize4(text)) {
+      if (id === unkId || id >= rows) continue;
+      if (used++ >= MAX_TOKENS) break;
+      const scale = scales[id];
+      const offset = id * dim;
+      for (let i2 = 0; i2 < dim; i2++) sum[i2] += weights[offset + i2] * scale;
+    }
+    let norm = 0;
+    for (let i2 = 0; i2 < dim; i2++) norm += sum[i2] * sum[i2];
+    norm = Math.sqrt(norm);
+    const out2 = new Array(dim);
+    for (let i2 = 0; i2 < dim; i2++) out2[i2] = norm > 0 ? sum[i2] / norm : 0;
+    return out2;
+  }
+  return { version: header.version, dim, tokenize: tokenize4, embed: embed2 };
+}
+function isBertPunctuation(ch) {
+  const c = ch.codePointAt(0);
+  if (c >= 33 && c <= 47 || c >= 58 && c <= 64 || c >= 91 && c <= 96 || c >= 123 && c <= 126) return true;
+  return new RegExp("\\p{P}", "u").test(ch);
+}
+function isCjk(c) {
+  return c >= 19968 && c <= 40959 || c >= 13312 && c <= 19903 || c >= 131072 && c <= 173791 || c >= 173824 && c <= 177983 || c >= 177984 && c <= 178207 || c >= 178208 && c <= 183983 || c >= 63744 && c <= 64255 || c >= 194560 && c <= 195103;
+}
+function normalize2(text) {
+  let out2 = "";
+  for (const ch of text) {
+    const c = ch.codePointAt(0);
+    if (c === 0 || c === 65533) continue;
+    if (/\s/u.test(ch)) {
+      out2 += " ";
+      continue;
+    }
+    if (new RegExp("\\p{C}", "u").test(ch)) continue;
+    out2 += isCjk(c) ? ` ${ch} ` : ch;
+  }
+  return out2.toLowerCase().normalize("NFD").replace(new RegExp("\\p{Mn}", "gu"), "");
+}
+function preTokenize(text) {
+  const words = [];
+  for (const chunk of text.split(" ")) {
+    let current = "";
+    for (const ch of chunk) {
+      if (isBertPunctuation(ch)) {
+        if (current) words.push(current);
+        words.push(ch);
+        current = "";
+      } else {
+        current += ch;
+      }
+    }
+    if (current) words.push(current);
+  }
+  return words;
+}
+function staticModelCandidates(moduleUrl = import.meta.url) {
+  const here = dirname4(fileURLToPath(moduleUrl));
+  const explicit = process.env["ERRATA_STATIC_MODEL"];
+  return [
+    ...explicit ? [explicit] : [],
+    join3(here, "resources", "models", STATIC_MODEL_FILE),
+    join3(here, "..", "assets", STATIC_MODEL_FILE)
+  ];
+}
+function loadStaticModel() {
+  if (loaded !== void 0) return loaded;
+  const path3 = staticModelCandidates().find((p) => existsSync4(p));
+  if (!path3) {
+    loadError = new Error(`no static model asset (looked in: ${staticModelCandidates().join(", ")})`);
+    loaded = null;
+    return loaded;
+  }
+  try {
+    loaded = decodeStaticAsset(readFileSync3(path3));
+  } catch (err2) {
+    loadError = err2 instanceof Error ? err2 : new Error(String(err2));
+    loaded = null;
+  }
+  return loaded;
+}
+function getStaticModelLoadError() {
+  return loadError;
+}
+var STATIC_MODEL_FILE, ASSET_MAGIC, MAX_TOKENS, loaded, loadError;
+var init_static = __esm({
+  "../../packages/embedding/src/static.ts"() {
+    "use strict";
+    STATIC_MODEL_FILE = "potion-base-8M.q8.bin";
+    ASSET_MAGIC = "ERRSTAT1";
+    MAX_TOKENS = 512;
+    loadError = null;
+  }
+});
+
+// ../../packages/embedding/src/bands.ts
+function cosineBandsFor(version3) {
+  return (version3 ? BANDS[version3] : void 0) ?? UNKNOWN;
+}
+var DESIGNED_FOR_MINILM, BANDS, UNKNOWN;
+var init_bands = __esm({
+  "../../packages/embedding/src/bands.ts"() {
+    "use strict";
+    DESIGNED_FOR_MINILM = {
+      dedup: 0.88,
+      softWriteMin: 0.8,
+      bindMin: 0.78,
+      nearMiss: 0.72,
+      judgeMin: 0.5,
+      predictionFloor: 0.5,
+      relevanceFloor: 0.25,
+      relatedWeak: 0.35,
+      relatedStrong: 0.45
+    };
+    BANDS = {
+      "hash-v1": DESIGNED_FOR_MINILM,
+      "minilm-l6-v2": DESIGNED_FOR_MINILM,
+      "potion-8m-q8": {
+        dedup: 0.895,
+        softWriteMin: 0.835,
+        bindMin: 0.83,
+        nearMiss: 0.775,
+        judgeMin: 0.335,
+        predictionFloor: 0.335,
+        relevanceFloor: 0.35,
+        relatedWeak: 0.49,
+        relatedStrong: 0.53
+      }
+    };
+    UNKNOWN = { ...DESIGNED_FOR_MINILM, relevanceFloor: 0.5 };
+  }
+});
+
 // ../../packages/embedding/src/model.ts
-import { mkdirSync as mkdirSync3, existsSync as existsSync4 } from "node:fs";
+import { mkdirSync as mkdirSync3, existsSync as existsSync5 } from "node:fs";
 import { homedir } from "node:os";
-import { dirname as dirname4, join as join3 } from "node:path";
+import { dirname as dirname5, join as join4 } from "node:path";
 import { createRequire } from "node:module";
 function semanticFloorFor(version3) {
-  if (version3 === EMBEDDING_VERSION || version3 === MODEL_EMBEDDING_VERSION) return 0.25;
-  return 0.5;
+  return cosineBandsFor(version3).relevanceFloor;
 }
 function noteHashFallback() {
   if (warnedHashFallback) return;
   if (process.env["ERRATA_EMBED_HASH_ONLY"] === "1") return;
   warnedHashFallback = true;
   console.warn(
-    `[errata] embedding model unavailable (${lastError?.message ?? "unknown"}) \u2014 falling back to ${EMBEDDING_VERSION} hash vectors; semantic ranking runs at reduced fidelity`
+    `[errata] embedding model unavailable (static: ${getStaticModelLoadError()?.message ?? "unknown"}; transformers: ${lastError?.message ?? "not attempted"}) \u2014 falling back to ${EMBEDDING_VERSION} hash vectors; semantic ranking runs at reduced fidelity`
   );
 }
 function getCacheDir() {
-  return process.env["ERRATA_MODEL_CACHE"] ?? join3(homedir(), ".errata", "models");
+  return process.env["ERRATA_MODEL_CACHE"] ?? join4(homedir(), ".errata", "models");
 }
 async function loadTransformers() {
+  let importError;
   try {
     return await import("@huggingface/transformers");
   } catch (err2) {
-    void err2;
+    importError = err2;
   }
   try {
-    const seaResourceBase = join3(
+    const seaResourceBase = join4(
       // execPath dir is where errata.exe lives; resources/ rides alongside.
-      dirname4(process.execPath),
+      dirname5(process.execPath),
       "resources",
       "_resolve.js"
     );
     const resourceRequire = createRequire(seaResourceBase);
     return resourceRequire("@huggingface/transformers");
   } catch (err2) {
-    lastError = err2 instanceof Error ? err2 : new Error(String(err2));
+    const message2 = (e) => (e instanceof Error ? e.message : String(e)).split("\n")[0];
+    lastError = new Error(`${message2(importError)} (SEA resources fallback: ${message2(err2)})`);
     return null;
   }
 }
 async function loadPipeline() {
   const cacheDir = getCacheDir();
-  if (!existsSync4(cacheDir)) mkdirSync3(cacheDir, { recursive: true });
+  if (!existsSync5(cacheDir)) mkdirSync3(cacheDir, { recursive: true });
   try {
     const tx = await loadTransformers();
     if (!tx) {
@@ -23920,6 +24101,14 @@ async function embedTextWithModel(text) {
   const out2 = await pipe2(text, { pooling: "mean", normalize: true });
   return Array.from(out2.data);
 }
+function embedTextSync(text) {
+  if (process.env["ERRATA_EMBED_HASH_ONLY"] !== "1") {
+    const staticModel2 = loadStaticModel();
+    if (staticModel2) return { vector: staticModel2.embed(text), version: staticModel2.version, dim: staticModel2.dim };
+  }
+  const v = embed(text);
+  return { vector: v, version: EMBEDDING_VERSION, dim: v.length };
+}
 async function embedBatchWithModelOrHash(texts) {
   if (texts.length === 0) return [];
   if (process.env["ERRATA_EMBED_HASH_ONLY"] === "1") {
@@ -23928,6 +24117,10 @@ async function embedBatchWithModelOrHash(texts) {
       return { vector: v, version: EMBEDDING_VERSION, dim: v.length };
     });
   }
+  const staticModel2 = loadStaticModel();
+  if (staticModel2) {
+    return texts.map((t) => ({ vector: staticModel2.embed(t), version: staticModel2.version, dim: staticModel2.dim }));
+  }
   try {
     const pipe2 = await ensureModelLoaded();
     if (pipe2) {
@@ -23957,6 +24150,10 @@ async function embedTextWithModelOrHash(text) {
     const v = embed(text);
     return { vector: v, version: EMBEDDING_VERSION, dim: v.length };
   }
+  const staticModel2 = loadStaticModel();
+  if (staticModel2) {
+    return { vector: staticModel2.embed(text), version: staticModel2.version, dim: staticModel2.dim };
+  }
   try {
     const v = await embedTextWithModel(text);
     return { vector: v, version: MODEL_EMBEDDING_VERSION, dim: v.length };
@@ -23971,6 +24168,8 @@ var init_model = __esm({
   "../../packages/embedding/src/model.ts"() {
     "use strict";
     init_src4();
+    init_static();
+    init_bands();
     MODEL_NAME = "Xenova/all-MiniLM-L6-v2";
     MODEL_EMBEDDING_DIM = 384;
     MODEL_EMBEDDING_VERSION = "minilm-l6-v2";
@@ -24035,6 +24234,8 @@ var init_src4 = __esm({
   "../../packages/embedding/src/index.ts"() {
     "use strict";
     init_model();
+    init_bands();
+    init_static();
     EMBEDDING_DIM = 256;
     EMBEDDING_VERSION = "hash-v1";
   }
@@ -24520,9 +24721,8 @@ function mintPatternNode(store, name2, ts) {
   const emb = embed(display);
   let best = null;
   let bestCos = 0;
-  for (const p of store.selectNodes({ labels: ["Pattern"], withEmbedding: true })) {
-    const e = p.embedding;
-    if (!e || e.length !== EMBEDDING_DIM) continue;
+  for (const p of store.selectNodes({ labels: ["Pattern"] })) {
+    const e = embed(canonicalizePatternText(p.description));
     let d = 0;
     for (let i2 = 0; i2 < EMBEDDING_DIM; i2++) d += e[i2] * emb[i2];
     if (d > bestCos) {
@@ -24532,13 +24732,7 @@ function mintPatternNode(store, name2, ts) {
   }
   const bestNode = best && bestCos >= PATTERN_DEDUP_COSINE ? store.getNode(best) : null;
   if (bestNode) return reinforce(bestNode, display);
-  store.mergeNode({
-    ...buildNode(store, id, "Pattern", display, ts, { source: "convo", provisional: true, observedCount: 1 }),
-    // Embedded inline (sync hash) so the node participates in the gate
-    // immediately — buildNode's empty embedding would leave every new pattern
-    // invisible to dedup until the nightly embed pass.
-    embedding: emb
-  });
+  store.mergeNode(buildNode(store, id, "Pattern", display, ts, { source: "convo", provisional: true, observedCount: 1 }));
   return id;
 }
 function titleCaseDomain(name2) {
@@ -27283,14 +27477,15 @@ async function resolveFoldCandidates(store, opts) {
     if (fresh.embedding.length > 0 && fresh.embedding.length === target.embedding.length && (fresh.attrs["embeddingVersion"] ?? "") === (target.attrs["embeddingVersion"] ?? "")) {
       cos = cosine(fresh.embedding, target.embedding);
     }
-    if (cos !== null && cos >= FOLD_EMBED_AUTO_COSINE) {
+    const bands = cosineBandsFor(fresh.attrs["embeddingVersion"]);
+    if (cos !== null && cos >= bands.dedup) {
       if (unseenMark(target)) neverExamined--;
       foldPair(store, fresh, target, opts.ts);
       report.folded++;
       report.foldedEmbedding++;
       continue;
     }
-    if (cos !== null && cos < FOLD_JUDGE_MIN_COSINE) {
+    if (cos !== null && cos < bands.judgeMin) {
       clearCandidate(store, fresh, opts.ts, target.id);
       report.rejected++;
       continue;
@@ -29239,8 +29434,8 @@ var init_bleed_memory = __esm({
 });
 
 // ../../packages/context-writer/src/bleed-rules.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readdirSync, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readdirSync, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join5 } from "node:path";
 function formatRuleFile(item2) {
   const frontmatter = item2.paths && item2.paths.length > 0 ? `---
 paths:
@@ -29253,21 +29448,21 @@ ${item2.body.trim()}
 `;
 }
 function bleedRules(rulesDir, items) {
-  if (!existsSync5(rulesDir)) mkdirSync4(rulesDir, { recursive: true });
+  if (!existsSync6(rulesDir)) mkdirSync4(rulesDir, { recursive: true });
   const wanted = new Map(items.map((i2) => [fileFor(i2.slug), i2]));
   let written = 0;
   let created = 0;
   for (const [file2, item2] of wanted) {
-    const path3 = join4(rulesDir, file2);
-    if (!existsSync5(path3)) created++;
+    const path3 = join5(rulesDir, file2);
+    if (!existsSync6(path3)) created++;
     writeFileSync4(path3, formatRuleFile(item2), "utf8");
     written++;
   }
   let pruned = 0;
   for (const f of readdirSync(rulesDir)) {
     if (!f.startsWith(PREFIX) || !f.endsWith(".md") || wanted.has(f)) continue;
-    if (readFileSync3(join4(rulesDir, f), "utf8").includes(MARKER)) {
-      rmSync(join4(rulesDir, f));
+    if (readFileSync4(join5(rulesDir, f), "utf8").includes(MARKER)) {
+      rmSync(join5(rulesDir, f));
       pruned++;
     }
   }
@@ -30650,9 +30845,9 @@ var init_src7 = __esm({
 // src/owner-only-file.ts
 import { chmodSync, statSync } from "node:fs";
 import { execFileSync } from "node:child_process";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 function system32(exe) {
-  return join5(process.env["SystemRoot"] ?? "C:\\Windows", "System32", exe);
+  return join6(process.env["SystemRoot"] ?? "C:\\Windows", "System32", exe);
 }
 function parseWhoamiSid(output) {
   const match2 = /"(S-1-\d+(?:-\d+)+)"/.exec(output);
@@ -30797,33 +30992,33 @@ __export(paths_exports, {
 });
 import { execFile } from "node:child_process";
 import { mkdirSync as mkdirSync5 } from "node:fs";
-import { dirname as dirname5, join as join6 } from "node:path";
+import { dirname as dirname6, join as join7 } from "node:path";
 function globalDir() {
   const p = envPaths("errata", { suffix: "" });
   return p.config;
 }
 function globalConfigPath() {
-  return process.env["ERRATA_CONFIG_PATH"] ?? join6(globalDir(), "config.json");
+  return process.env["ERRATA_CONFIG_PATH"] ?? join7(globalDir(), "config.json");
 }
 function daemonLogPath() {
   mkdirSync5(globalDir(), { recursive: true });
-  return join6(globalDir(), "daemon.log");
+  return join7(globalDir(), "daemon.log");
 }
 function globalDaemonLock() {
-  return process.env["ERRATA_DAEMON_LOCK"] ?? join6(globalDir(), "daemon.lock");
+  return process.env["ERRATA_DAEMON_LOCK"] ?? join7(globalDir(), "daemon.lock");
 }
 function sharedStorePath() {
-  return process.env["ERRATA_SHARED_DB"] ?? join6(globalDir(), "shared", "graph.db");
+  return process.env["ERRATA_SHARED_DB"] ?? join7(globalDir(), "shared", "graph.db");
 }
 function workspaceDir(workspaceRoot) {
-  return join6(workspaceRoot, ".errata");
+  return join7(workspaceRoot, ".errata");
 }
 function ensureDir(p) {
   mkdirSync5(p, { recursive: true });
   return p;
 }
 function ensureParent(p) {
-  mkdirSync5(dirname5(p), { recursive: true });
+  mkdirSync5(dirname6(p), { recursive: true });
   return p;
 }
 function attribHasNotIndexed(attribOutput, path3) {
@@ -30834,7 +31029,7 @@ function excludeFromIndexing(dir, run3 = execFile) {
   if (process.platform !== "win32") return;
   run3("attrib", [dir], { windowsHide: true }, (err2, stdout) => {
     if (err2 || attribHasNotIndexed(String(stdout), dir)) return;
-    run3("attrib", ["+I", join6(dir, "*"), "/S", "/D"], { windowsHide: true }, () => {
+    run3("attrib", ["+I", join7(dir, "*"), "/S", "/D"], { windowsHide: true }, () => {
       run3("attrib", ["+I", dir], { windowsHide: true }, () => {
       });
     });
@@ -30845,15 +31040,15 @@ function workspacePaths(root) {
   return {
     root,
     configDir: dir,
-    workspaceJson: join6(dir, "workspace.json"),
-    eventLog: join6(dir, "eventlog.sqlite"),
-    castalia: join6(dir, "castalia.db"),
-    reviewQueue: join6(dir, "review-queue.json"),
-    outbox: join6(dir, "outbox"),
-    daemonLock: join6(dir, "daemon.lock"),
-    identityAudit: join6(dir, "identity-audit.log"),
-    skillsDir: join6(dir, "skills"),
-    skillsManifest: join6(dir, "skills.json")
+    workspaceJson: join7(dir, "workspace.json"),
+    eventLog: join7(dir, "eventlog.sqlite"),
+    castalia: join7(dir, "castalia.db"),
+    reviewQueue: join7(dir, "review-queue.json"),
+    outbox: join7(dir, "outbox"),
+    daemonLock: join7(dir, "daemon.lock"),
+    identityAudit: join7(dir, "identity-audit.log"),
+    skillsDir: join7(dir, "skills"),
+    skillsManifest: join7(dir, "skills.json")
   };
 }
 var init_paths = __esm({
@@ -30864,7 +31059,7 @@ var init_paths = __esm({
 });
 
 // src/config.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
 import { randomUUID as randomUUID2 } from "node:crypto";
 function mcpUrlFor(cloudUrl) {
   return `${cloudUrl.replace(/\/+$/, "")}/mcp`;
@@ -30896,13 +31091,13 @@ function defaultConfig() {
 }
 function loadConfig() {
   const p = globalConfigPath();
-  if (!existsSync6(p)) {
+  if (!existsSync7(p)) {
     ensureDir(globalDir());
     const cfg = defaultConfig();
     saveConfig({ ...cfg, cloudUrl: DEFAULT_CLOUD_URL });
     return cfg;
   }
-  const raw2 = readFileSync4(p, "utf8").replace(/^\uFEFF/, "");
+  const raw2 = readFileSync5(p, "utf8").replace(/^\uFEFF/, "");
   const parsed = JSON.parse(raw2);
   const base = defaultConfig();
   const envCloudUrl = process.env["ERRATA_CLOUD_URL"];
@@ -33817,13 +34012,16 @@ var init_review_detector = __esm({
 
 // ../../packages/generalizer/src/nemori-gate.ts
 function nemoriDecide(input) {
-  if (input.topCosine >= NEMORI_DEDUP_COSINE && input.topId) {
+  const dedup = input.bands?.dedup ?? NEMORI_DEDUP_COSINE;
+  const softWriteMin = input.bands?.softWriteMin ?? NEMORI_SOFT_WRITE_MIN_COSINE;
+  const softWriteMax = input.bands ? dedup : NEMORI_SOFT_WRITE_MAX_COSINE;
+  if (input.topCosine >= dedup && input.topId) {
     return { kind: "REINFORCE", existingId: input.topId };
   }
   if (input.surprise >= NEMORI_HIGH_SURPRISE_THRESHOLD) {
     return { kind: "WRITE_FULL", reason: "high-surprise" };
   }
-  const inSoftBand = input.topCosine >= NEMORI_SOFT_WRITE_MIN_COSINE && input.topCosine < NEMORI_SOFT_WRITE_MAX_COSINE;
+  const inSoftBand = input.topCosine >= softWriteMin && input.topCosine < softWriteMax;
   if (input.isPredicted || inSoftBand) {
     const s = Math.max(0, Math.min(1, input.surprise));
     const alpha = NEMORI_SOFT_ALPHA_MIN + (NEMORI_SOFT_ALPHA_MAX - NEMORI_SOFT_ALPHA_MIN) * s;
@@ -33926,7 +34124,7 @@ var init_diagnostic_matcher = __esm({
 });
 
 // ../../packages/generalizer/src/generalizer.ts
-import { isAbsolute, join as join7, relative } from "node:path";
+import { isAbsolute, join as join8, relative } from "node:path";
 async function runGeneralizer(opts) {
   const report = {
     eventsProcessed: 0,
@@ -34034,7 +34232,7 @@ function extractDiagnostics(ev) {
 function diagRelPath(file2, cwd, workspaceRoot) {
   const norm = (p) => p.replace(/\\/g, "/");
   if (!workspaceRoot) return norm(file2);
-  const abs = isAbsolute(file2) ? file2 : join7(cwd ?? workspaceRoot, file2);
+  const abs = isAbsolute(file2) ? file2 : join8(cwd ?? workspaceRoot, file2);
   return norm(relative(workspaceRoot, abs));
 }
 function extractErrorSignature(ev) {
@@ -34066,7 +34264,10 @@ function rankOpenProblemNeighbors(store, embedding, limit = 5) {
     where: [{ embedding: embedding.vector.length > 0 ? "present" : "absent" }],
     withEmbedding: true
   }).filter(
-    (p) => p.embedding.length === embedding.vector.length && (p.attrs["embeddingVersion"] === embedding.version || !p.attrs["embeddingVersion"])
+    (p) => p.embedding.length === embedding.vector.length && // Unversioned vectors predate the model embedders: they are hash-v1. The
+    // old "unversioned matches anything" leaned on hash-v1 (256-d) never
+    // sharing a length with the model; potion-8m-q8 is 256-d too.
+    String(p.attrs["embeddingVersion"] ?? EMBEDDING_VERSION) === embedding.version
   ).map((p) => ({ id: p.id, score: cosine(embedding.vector, p.embedding) })).sort((a, b) => b.score - a.score).slice(0, limit).map(({ id, score: score2 }) => {
     const p = store.getNode(id);
     return {
@@ -34079,8 +34280,6 @@ function rankOpenProblemNeighbors(store, embedding, limit = 5) {
   });
 }
 function mergeProblemsByEmbedding(store, opts) {
-  const minCosine = opts.minCosine ?? NEMORI_DEDUP_COSINE;
-  const NEAR_MISS_FLOOR = 0.72;
   const report = { clusters: 0, merged: 0, nearMissMarked: 0 };
   if (opts.freshSince !== void 0 && store.countNodes({ labels: ["Problem"], where: [...OPEN_UNMERGED, HAS_VECTOR, { column: "created_at", gt: opts.freshSince }] }) === 0) {
     return report;
@@ -34105,10 +34304,11 @@ function mergeProblemsByEmbedding(store, opts) {
         if ((a.attrs["embeddingVersion"] ?? "") !== (b.attrs["embeddingVersion"] ?? "")) continue;
         if (isConstraintProblem(a) !== isConstraintProblem(b)) continue;
         const cos = cosine(a.embedding, b.embedding);
-        if (cos >= minCosine) {
+        const bands = bandsOf(a);
+        if (cos >= (opts.minCosine ?? bands.dedup)) {
           cluster.push(b);
           consumed.add(b.id);
-        } else if (cos >= NEAR_MISS_FLOOR) {
+        } else if (cos >= bands.nearMiss) {
           const [younger, elder] = a.createdAt >= b.createdAt ? [a, b] : [b, a];
           actions.push({ kind: "mark", younger: younger.id, elder: elder.id, cos });
         }
@@ -34142,7 +34342,6 @@ function mergeProblemsByEmbedding(store, opts) {
   return report;
 }
 function bindResolvedRegressions(store, opts) {
-  const minCosine = opts.minCosine ?? NEMORI_DEDUP_COSINE;
   const watermarkRaw = store.getMeta?.("regression_sweep_at") ?? null;
   const full = watermarkRaw === null;
   const since = full ? 0 : Number(watermarkRaw) || 0;
@@ -34172,7 +34371,7 @@ function bindResolvedRegressions(store, opts) {
         if ((r.attrs["embeddingVersion"] ?? "") !== (f.attrs["embeddingVersion"] ?? "")) continue;
         if (isConstraintProblem(f) !== isConstraintProblem(r)) continue;
         const s = cosine(f.embedding, r.embedding);
-        if (s >= minCosine && (!best || s > best.s)) best = { node: r, s };
+        if (s >= (opts.minCosine ?? bandsOf(f).dedup) && (!best || s > best.s)) best = { node: r, s };
       }
       if (!best) continue;
       if (store.outEdges(f.id, ["REGRESSION_OF"]).some((e) => e.to === best.node.id)) continue;
@@ -34221,13 +34420,14 @@ function bindCanonicalNeighbors(store, opts) {
       store.outEdges(p.id, ["MATCHES", "INSTANCE_OF", "RELATES_TO"]).map((e) => e.to)
     );
     if (existing.size >= k) continue;
+    const bands = bandsOf(p);
     const ranked2 = pool.filter(
       (c) => c.id !== p.id && !existing.has(c.id) && c.embedding.length === p.embedding.length && (c.attrs["embeddingVersion"] ?? "") === (p.attrs["embeddingVersion"] ?? "")
-    ).map((c) => ({ c, s: cosine(p.embedding, c.embedding) })).filter((x) => x.s >= CANONICAL_BIND_MIN && x.s < NEMORI_DEDUP_COSINE).sort((a, b) => b.s - a.s);
+    ).map((c) => ({ c, s: cosine(p.embedding, c.embedding) })).filter((x) => x.s >= bands.bindMin && x.s < bands.dedup).sort((a, b) => b.s - a.s);
     const picked = [];
     for (const cand of ranked2) {
       if (picked.length + existing.size >= k) break;
-      if (picked.some((q) => cosine(q.c.embedding, cand.c.embedding) >= NEMORI_DEDUP_COSINE)) continue;
+      if (picked.some((q) => cosine(q.c.embedding, cand.c.embedding) >= bands.dedup)) continue;
       picked.push(cand);
     }
     for (const { c, s } of picked) {
@@ -34279,6 +34479,7 @@ async function ingestErrorSignature(opts, sig, commandSig) {
     topCosine = 1;
     topId = openMatch.id;
   }
+  const bands = cosineBandsFor(candidateEmbedding.version);
   const titans = titansSurpriseFromNeighbors(neighbors);
   const decision = nemoriDecide({
     surprise: titans.surprise,
@@ -34287,7 +34488,8 @@ async function ingestErrorSignature(opts, sig, commandSig) {
     // The prior (the neighbor search above) anticipated this if it surfaced a
     // real neighbor — not just embedding noise. Below the soft band, so a
     // low-surprise predicted observation dampens instead of writing full.
-    isPredicted: topId !== null && topCosine >= NEMORI_PREDICTION_FLOOR
+    isPredicted: topId !== null && topCosine >= bands.predictionFloor,
+    bands
   });
   let node2;
   const prevTier = openMatch?.memoryTier;
@@ -34952,7 +35154,7 @@ function reconcileDiagnostics(store, workspaceId2, relPath, diags, t, command) {
   }
   return { opened, resolved };
 }
-var GENERALIZER_CURSOR, GENERALIZER_KINDS, GENERALIZER_BATCH, OPEN_UNMERGED, HAS_VECTOR, CANONICAL_BIND_MIN, ANCHOR_LABELS2, DIAG_SEVERITY_ERROR;
+var bandsOf, GENERALIZER_CURSOR, GENERALIZER_KINDS, GENERALIZER_BATCH, OPEN_UNMERGED, HAS_VECTOR, ANCHOR_LABELS2, DIAG_SEVERITY_ERROR;
 var init_generalizer = __esm({
   "../../packages/generalizer/src/generalizer.ts"() {
     "use strict";
@@ -34965,6 +35167,7 @@ var init_generalizer = __esm({
     init_review_detector();
     init_nemori_gate();
     init_diagnostic_matcher();
+    bandsOf = (n) => cosineBandsFor(n.attrs["embeddingVersion"]);
     GENERALIZER_CURSOR = "generalizer";
     GENERALIZER_KINDS = [
       "shell.command",
@@ -34977,7 +35180,6 @@ var init_generalizer = __esm({
       { attr: "mergedInto", absent: true }
     ];
     HAS_VECTOR = { embedding: "present" };
-    CANONICAL_BIND_MIN = 0.78;
     ANCHOR_LABELS2 = ["Function", "Method", "Class"];
     DIAG_SEVERITY_ERROR = 1;
   }
@@ -35508,8 +35710,7 @@ async function ensureNodeEmbedded(store, nodeId, opts = {}) {
   let result;
   try {
     if (opts.mode === "hash") {
-      const v = embed(text);
-      result = { vector: v, version: EMBEDDING_VERSION, dim: v.length };
+      result = embedTextSync(text);
     } else {
       const r = (await embedBatchWithModelOrHash([text]))[0];
       if (!r) return false;
@@ -35605,11 +35806,11 @@ async function embedNodesByLabels(store, labels, opts = {}) {
     }
   }
   if (candidates.length === 0) {
-    complete(held?.version ?? (hashOnly ? EMBEDDING_VERSION : null));
+    complete(held?.version ?? (hashOnly ? embedTextSync("").version : null));
     report.durationMs = Date.now() - started2;
     return report;
   }
-  const currentVersion = hashOnly ? EMBEDDING_VERSION : (await embedBatchWithModelOrHash(["probe"]))[0]?.version ?? "unknown";
+  const currentVersion = hashOnly ? embedTextSync("probe").version : (await embedBatchWithModelOrHash(["probe"]))[0]?.version ?? "unknown";
   if (changedIds !== null && held?.version && held.version !== currentVersion) {
     const { incrementalKey: _incremental, ...fullOpts } = opts;
     return embedNodesByLabels(store, labels, fullOpts).then((full) => {
@@ -35632,10 +35833,7 @@ async function embedNodesByLabels(store, labels, opts = {}) {
     const batch = todo.slice(i2, i2 + BATCH_SIZE);
     let results;
     try {
-      results = hashOnly ? batch.map((b) => {
-        const v = embed(b.text);
-        return { vector: v, version: EMBEDDING_VERSION, dim: v.length };
-      }) : await embedBatchWithModelOrHash(batch.map((b) => b.text));
+      results = hashOnly ? batch.map((b) => embedTextSync(b.text)) : await embedBatchWithModelOrHash(batch.map((b) => b.text));
     } catch {
       report.failed += batch.length;
       continue;
@@ -35711,7 +35909,7 @@ function nodeFreshness(node2, currentIngestSeq) {
   });
 }
 function scoreCandidate(candidate, ctx = {}, weights) {
-  const sameVersion = !ctx.seedEmbeddingVersion || !candidate.attrs["embeddingVersion"] || candidate.attrs["embeddingVersion"] === ctx.seedEmbeddingVersion;
+  const sameVersion = String(candidate.attrs["embeddingVersion"] ?? EMBEDDING_VERSION) === String(ctx.seedEmbeddingVersion ?? EMBEDDING_VERSION);
   const comparable = ctx.seedEmbedding != null && candidate.embedding.length === ctx.seedEmbedding.length && sameVersion;
   const semantic = comparable ? cosine(ctx.seedEmbedding, candidate.embedding) : void 0;
   const semanticUnknown = ctx.seedEmbedding != null && !comparable;
@@ -36353,8 +36551,8 @@ 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 join8 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join9 } from "node:path";
 function live(n) {
   return n != null && n.validTo == null && historyReadPolicy(n, { mode: "passive" }).allow;
 }
@@ -36423,17 +36621,17 @@ function contextCard(store, snapshot) {
   return deliveredCard(store, intent ? `${count2} for \u201C${clipIntent(intent)}\u201D` : `${count2} in context`, delivered);
 }
 function writeContextCard(root, hash2, card) {
-  writeFileSync6(join8(root, ".errata", CONTEXT_CARD_FILE), JSON.stringify({
+  writeFileSync6(join9(root, ".errata", CONTEXT_CARD_FILE), JSON.stringify({
     hash: hash2,
     card,
     line: card && recallCardEnabled() ? renderRecallLine(card) : null
   }));
 }
 function readContextCard(root, hash2) {
-  const path3 = join8(root, ".errata", CONTEXT_CARD_FILE);
-  if (!existsSync7(path3)) return null;
+  const path3 = join9(root, ".errata", CONTEXT_CARD_FILE);
+  if (!existsSync8(path3)) return null;
   try {
-    const saved = JSON.parse(readFileSync5(path3, "utf8"));
+    const saved = JSON.parse(readFileSync6(path3, "utf8"));
     return saved.hash === hash2 ? saved.card ?? null : null;
   } catch {
     return null;
@@ -36501,9 +36699,9 @@ var init_recall_signal = __esm({
 });
 
 // src/session-registry.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6, realpathSync, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync7, realpathSync, writeFileSync as writeFileSync7 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { basename as basename2, dirname as dirname6, resolve } from "node:path";
+import { basename as basename2, dirname as dirname7, resolve } from "node:path";
 function shipsFromWorkspace(root, env2 = process.env) {
   return Boolean(env2["VITEST"]) || !isScratchWorkspace(root);
 }
@@ -36511,8 +36709,8 @@ function isScratchWorkspace(root, tmp = tmpdir2()) {
   const norm = (p) => {
     let cursor = resolve(p);
     const suffix = [];
-    while (!existsSync8(cursor)) {
-      const parent = dirname6(cursor);
+    while (!existsSync9(cursor)) {
+      const parent = dirname7(cursor);
       if (parent === cursor) break;
       suffix.unshift(basename2(cursor));
       cursor = parent;
@@ -36595,9 +36793,9 @@ function createSessionRegistry(opts = {}) {
   return registry2;
 }
 function loadOrigins(path3) {
-  if (!path3 || !existsSync8(path3)) return [];
+  if (!path3 || !existsSync9(path3)) return [];
   try {
-    const raw2 = JSON.parse(readFileSync6(path3, "utf8"));
+    const raw2 = JSON.parse(readFileSync7(path3, "utf8"));
     return Object.entries(raw2).flatMap(([k, v]) => typeof v === "string" ? [[k, v]] : []);
   } catch {
     return [];
@@ -36632,11 +36830,11 @@ var init_session_registry = __esm({
 });
 
 // src/review.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "node:fs";
 function loadReviewQueue(paths) {
-  if (!existsSync9(paths.reviewQueue)) return [];
+  if (!existsSync10(paths.reviewQueue)) return [];
   try {
-    return JSON.parse(readFileSync7(paths.reviewQueue, "utf8"));
+    return JSON.parse(readFileSync8(paths.reviewQueue, "utf8"));
   } catch {
     return [];
   }
@@ -36713,14 +36911,14 @@ var init_consent = __esm({
 
 // src/git-remote.ts
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync10, readFileSync as readFileSync8, statSync as statSync3 } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join9, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync9, statSync as statSync3 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join10, resolve as resolve2 } from "node:path";
 function resolveGitDir(root) {
-  const dotGit = join9(root, ".git");
+  const dotGit = join10(root, ".git");
   try {
     const st = statSync3(dotGit);
     if (st.isDirectory()) return dotGit;
-    const m = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync8(dotGit, "utf8"));
+    const m = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync9(dotGit, "utf8"));
     if (!m) return null;
     const dir = m[1];
     return isAbsolute2(dir) ? dir : resolve2(root, dir);
@@ -36729,22 +36927,22 @@ function resolveGitDir(root) {
   }
 }
 function gitConfigPath(gitDir) {
-  const commondirFile = join9(gitDir, "commondir");
-  if (existsSync10(commondirFile)) {
-    const common = readFileSync8(commondirFile, "utf8").trim();
+  const commondirFile = join10(gitDir, "commondir");
+  if (existsSync11(commondirFile)) {
+    const common = readFileSync9(commondirFile, "utf8").trim();
     const commonDir = isAbsolute2(common) ? common : resolve2(gitDir, common);
-    return join9(commonDir, "config");
+    return join10(commonDir, "config");
   }
-  return join9(gitDir, "config");
+  return join10(gitDir, "config");
 }
 function readRemotes(root) {
   const gitDir = resolveGitDir(root);
   if (!gitDir) return [];
   const cfgPath = gitConfigPath(gitDir);
-  if (!existsSync10(cfgPath)) return [];
+  if (!existsSync11(cfgPath)) return [];
   let txt;
   try {
-    txt = readFileSync8(cfgPath, "utf8");
+    txt = readFileSync9(cfgPath, "utf8");
   } catch {
     return [];
   }
@@ -36799,9 +36997,9 @@ var init_git_remote = __esm({
 });
 
 // src/profile.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "node:fs";
 import { createHash as createHash5 } from "node:crypto";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function workspaceId(root) {
   return "wp_" + createHash5("sha256").update(root).digest("hex").slice(0, 12);
 }
@@ -36824,8 +37022,8 @@ function refreshRepoLocator(root, profile) {
 }
 function loadProfile(root) {
   const p = workspacePaths(root);
-  if (!existsSync11(p.workspaceJson)) return null;
-  return JSON.parse(readFileSync9(p.workspaceJson, "utf8"));
+  if (!existsSync12(p.workspaceJson)) return null;
+  return JSON.parse(readFileSync10(p.workspaceJson, "utf8"));
 }
 function saveProfile(root, profile) {
   const p = workspacePaths(root);
@@ -36838,13 +37036,13 @@ function autodetectProfile(root) {
   const p = emptyProfile(id, name2);
   const locator = detectRepoLocator(root);
   if (locator) p.repoLocator = locator;
-  const pkgPath = join10(root, "package.json");
-  if (existsSync11(pkgPath)) {
+  const pkgPath = join11(root, "package.json");
+  if (existsSync12(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
       const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
       p.languages.push("javascript");
-      if (existsSync11(join10(root, "tsconfig.json")) || deps["typescript"]) {
+      if (existsSync12(join11(root, "tsconfig.json")) || deps["typescript"]) {
         p.languages.push("typescript");
       }
       const nodeVer = pkg.engines?.node?.trim();
@@ -36865,10 +37063,10 @@ function autodetectProfile(root) {
     } catch {
     }
   }
-  const pyproject = join10(root, "pyproject.toml");
-  if (existsSync11(pyproject)) {
+  const pyproject = join11(root, "pyproject.toml");
+  if (existsSync12(pyproject)) {
     try {
-      const txt = readFileSync9(pyproject, "utf8");
+      const txt = readFileSync10(pyproject, "utf8");
       const py = /python\s*=\s*"([^"]+)"/.exec(txt)?.[1];
       p.languages.push("python");
       p.stack.push(`python@${py ?? "3"}`);
@@ -36879,16 +37077,16 @@ function autodetectProfile(root) {
     } catch {
     }
   }
-  const reqs = join10(root, "requirements.txt");
-  if (existsSync11(reqs)) {
+  const reqs = join11(root, "requirements.txt");
+  if (existsSync12(reqs)) {
     if (!p.languages.includes("python")) p.languages.push("python");
     if (!p.stack.includes("python@3")) p.stack.push("python@3");
   }
-  if (existsSync11(join10(root, "go.mod"))) {
+  if (existsSync12(join11(root, "go.mod"))) {
     p.languages.push("go");
     p.stack.push("go");
   }
-  if (existsSync11(join10(root, "Cargo.toml"))) {
+  if (existsSync12(join11(root, "Cargo.toml"))) {
     p.languages.push("rust");
     p.stack.push("rust");
   }
@@ -36993,32 +37191,32 @@ var init_identity2 = __esm({
 });
 
 // src/checkout-root.ts
-import { existsSync as existsSync12, readFileSync as readFileSync10 } from "node:fs";
-import { basename as basename3, dirname as dirname7, isAbsolute as isAbsolute3, join as join11, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
+import { basename as basename3, dirname as dirname8, isAbsolute as isAbsolute3, join as join12, resolve as resolve3 } from "node:path";
 function nearestGitRoot(dir) {
   let cur = resolve3(dir);
   for (; ; ) {
-    if (existsSync12(join11(cur, ".git"))) return cur;
-    const parent = dirname7(cur);
+    if (existsSync13(join12(cur, ".git"))) return cur;
+    const parent = dirname8(cur);
     if (parent === cur) return null;
     cur = parent;
   }
 }
 function mainCheckoutOfWorktree(root) {
   const gitDir = resolveGitDir(root);
-  if (!gitDir || gitDir === join11(root, ".git")) return null;
-  const commondirFile = join11(gitDir, "commondir");
-  if (!existsSync12(commondirFile)) return null;
+  if (!gitDir || gitDir === join12(root, ".git")) return null;
+  const commondirFile = join12(gitDir, "commondir");
+  if (!existsSync13(commondirFile)) return null;
   let common;
   try {
-    common = readFileSync10(commondirFile, "utf8").trim();
+    common = readFileSync11(commondirFile, "utf8").trim();
   } catch {
     return null;
   }
   const commonDir = resolve3(isAbsolute3(common) ? common : resolve3(gitDir, common));
   if (basename3(commonDir) !== ".git") return null;
-  const main2 = dirname7(commonDir);
-  return existsSync12(join11(main2, ".git")) ? main2 : null;
+  const main2 = dirname8(commonDir);
+  return existsSync13(join12(main2, ".git")) ? main2 : null;
 }
 function checkoutRootOf(cwd) {
   const root = nearestGitRoot(cwd);
@@ -37037,7 +37235,7 @@ var init_checkout_root = __esm({
 
 // src/process-identity.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 function readProcessIdentity(pid, fresh = false) {
   if (!Number.isSafeInteger(pid) || pid <= 0) return null;
   if (pid === process.pid && self) return self;
@@ -37062,10 +37260,10 @@ function readProcessIdentity(pid, fresh = false) {
       if (!/^\d+$/.test(ticks)) return null;
       value = { key: `win32:${ticks}`, bornAt: Number((BigInt(ticks) - 621355968000000000n) / 10000n) };
     } else if (process.platform === "linux") {
-      const stat4 = readFileSync11(`/proc/${pid}/stat`, "utf8");
+      const stat4 = readFileSync12(`/proc/${pid}/stat`, "utf8");
       const ticks = stat4.slice(stat4.lastIndexOf(")") + 2).split(" ")[19];
-      const bootId = readFileSync11("/proc/sys/kernel/random/boot_id", "utf8").trim();
-      const boot = /^btime (\d+)$/m.exec(readFileSync11("/proc/stat", "utf8"))?.[1];
+      const bootId = readFileSync12("/proc/sys/kernel/random/boot_id", "utf8").trim();
+      const boot = /^btime (\d+)$/m.exec(readFileSync12("/proc/stat", "utf8"))?.[1];
       const hz = Number(run3("getconf", ["CLK_TCK"]));
       if (!boot || !/^\d+$/.test(ticks) || !Number.isFinite(hz) || hz <= 0) return null;
       value = { key: `linux:${bootId}:${ticks}`, bornAt: Number(boot) * 1e3 + Number(ticks) * 1e3 / hz };
@@ -37091,7 +37289,7 @@ var init_process_identity = __esm({
 });
 
 // src/lock.ts
-import { existsSync as existsSync13, readFileSync as readFileSync12, unlinkSync as unlinkSync2 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync13, unlinkSync as unlinkSync2 } from "node:fs";
 function daemonLockPayload(lock) {
   return JSON.stringify({
     pid: lock.pid,
@@ -37133,9 +37331,9 @@ function isProcessAlive(pid) {
   }
 }
 function readDaemonLock(lockPath) {
-  if (!existsSync13(lockPath)) return null;
+  if (!existsSync14(lockPath)) return null;
   try {
-    return parseDaemonLock(readFileSync12(lockPath, "utf8"));
+    return parseDaemonLock(readFileSync13(lockPath, "utf8"));
   } catch {
     return null;
   }
@@ -37172,14 +37370,14 @@ async function waitForDaemonExit(lock, timeoutMs, pollMs = 200) {
 }
 function releaseOwnLock(lockPath) {
   try {
-    if (parseDaemonLock(readFileSync12(lockPath, "utf8"))?.pid === process.pid) unlinkSync2(lockPath);
+    if (parseDaemonLock(readFileSync13(lockPath, "utf8"))?.pid === process.pid) unlinkSync2(lockPath);
   } catch {
   }
 }
 function stopLockedDaemon(lockPath) {
   let original;
   try {
-    original = readFileSync12(lockPath, "utf8");
+    original = readFileSync13(lockPath, "utf8");
   } catch {
     return "missing";
   }
@@ -37187,7 +37385,7 @@ function stopLockedDaemon(lockPath) {
   if (!lock) return "unknown";
   const state = daemonLockState(lock, true);
   try {
-    if (readFileSync12(lockPath, "utf8") !== original) return "changed";
+    if (readFileSync13(lockPath, "utf8") !== original) return "changed";
   } catch {
     return "changed";
   }
@@ -37212,16 +37410,16 @@ var init_lock = __esm({
 });
 
 // src/registry.ts
-import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join13 } from "node:path";
 function registryPath() {
-  return process.env["ERRATA_REGISTRY_PATH"] ?? join12(globalDir(), "workspaces.json");
+  return process.env["ERRATA_REGISTRY_PATH"] ?? join13(globalDir(), "workspaces.json");
 }
 function read() {
   const p = registryPath();
-  if (!existsSync14(p)) return { version: 1, workspaces: {} };
+  if (!existsSync15(p)) return { version: 1, workspaces: {} };
   try {
-    const parsed = JSON.parse(readFileSync13(p, "utf8"));
+    const parsed = JSON.parse(readFileSync14(p, "utf8"));
     return { version: 1, workspaces: parsed.workspaces ?? {} };
   } catch {
     return { version: 1, workspaces: {} };
@@ -37229,9 +37427,9 @@ function read() {
 }
 function registryCorrupt() {
   const p = registryPath();
-  if (!existsSync14(p)) return false;
+  if (!existsSync15(p)) return false;
   try {
-    JSON.parse(readFileSync13(p, "utf8"));
+    JSON.parse(readFileSync14(p, "utf8"));
     return false;
   } catch {
     return true;
@@ -37284,7 +37482,7 @@ function pruneMissingWorkspaces() {
   const reg = read();
   const removed = [];
   for (const [id, entry] of Object.entries(reg.workspaces)) {
-    if (!existsSync14(entry.path)) {
+    if (!existsSync15(entry.path)) {
       removed.push(entry);
       delete reg.workspaces[id];
     }
@@ -37293,7 +37491,7 @@ function pruneMissingWorkspaces() {
   return removed;
 }
 function workspaceStatus(entry) {
-  const missing = !existsSync14(entry.path);
+  const missing = !existsSync15(entry.path);
   const lockPath = workspacePaths(entry.path).daemonLock;
   let running = false;
   let webUiUrl = null;
@@ -39324,22 +39522,22 @@ var init_daemon_generalize_client = __esm({
 
 // ../../packages/indexer/src/parse-cache.ts
 import { createHash as createHash6 } from "node:crypto";
-import { existsSync as existsSync15, mkdirSync as mkdirSync6, readFileSync as readFileSync14, readdirSync as readdirSync2, rmSync as rmSync2, statSync as statSync4, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync6, readFileSync as readFileSync15, readdirSync as readdirSync2, rmSync as rmSync2, statSync as statSync4, writeFileSync as writeFileSync11 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function parseCacheDir() {
-  return process.env["ERRATA_PARSE_CACHE"] ?? join13(homedir3(), ".errata", "parse-cache");
+  return process.env["ERRATA_PARSE_CACHE"] ?? join14(homedir3(), ".errata", "parse-cache");
 }
 function parseCacheKey(source, providerId) {
   return createHash6("sha256").update(`${PARSE_CACHE_VERSION}:${providerId}:${source}`).digest("hex");
 }
 function entryPath(dir, key) {
-  return join13(dir, key.slice(0, 2), `${key.slice(2)}.json`);
+  return join14(dir, key.slice(0, 2), `${key.slice(2)}.json`);
 }
 function readParseCache(dir, key) {
   const file2 = entryPath(dir, key);
   try {
-    const raw2 = readFileSync14(file2, "utf8");
+    const raw2 = readFileSync15(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 ?? [] };
@@ -39358,7 +39556,7 @@ function writeParseCache(dir, key, providerId, value) {
     const body2 = JSON.stringify(envelope);
     if (body2.length > MAX_ENTRY_BYTES) return;
     const file2 = entryPath(dir, key);
-    mkdirSync6(join13(dir, key.slice(0, 2)), { recursive: true });
+    mkdirSync6(join14(dir, key.slice(0, 2)), { recursive: true });
     writeFileSync11(file2, body2);
   } catch {
   }
@@ -39368,9 +39566,9 @@ function sweepParseCacheOnce(dir, now = Date.now()) {
   sweptThisProcess = true;
   let removed = 0;
   try {
-    if (!existsSync15(dir)) return 0;
+    if (!existsSync16(dir)) return 0;
     for (const bucket of readdirSync2(dir)) {
-      const bucketDir = join13(dir, bucket);
+      const bucketDir = join14(dir, bucket);
       let names;
       try {
         names = readdirSync2(bucketDir);
@@ -39378,7 +39576,7 @@ function sweepParseCacheOnce(dir, now = Date.now()) {
         continue;
       }
       for (const name2 of names) {
-        const file2 = join13(bucketDir, name2);
+        const file2 = join14(bucketDir, name2);
         try {
           if (now - statSync4(file2).mtimeMs > ENTRY_TTL_MS) {
             rmSync2(file2, { force: true });
@@ -39626,9 +39824,9 @@ var init_identity3 = __esm({
 });
 
 // ../../packages/indexer/src/pipeline.ts
-import { appendFileSync, readFileSync as readFileSync15, statSync as statSync5 } from "node:fs";
+import { appendFileSync, readFileSync as readFileSync16, statSync as statSync5 } from "node:fs";
 import { readdir } from "node:fs/promises";
-import { extname, join as join14, relative as relative2, sep } from "node:path";
+import { extname, join as join15, relative as relative2, sep } from "node:path";
 import { createHash as createHash7 } from "node:crypto";
 import { execFileSync as execFileSync3 } from "node:child_process";
 function nowTs() {
@@ -39777,7 +39975,7 @@ async function incrementalReindex(store, rootPath, workspaceId2, changedAbsPaths
   for (const rel of [...changedRelPaths]) {
     let h;
     try {
-      h = createHash7("sha256").update(readFileSync15(join14(rootPath, rel))).digest("hex");
+      h = createHash7("sha256").update(readFileSync16(join15(rootPath, rel))).digest("hex");
     } catch {
       continue;
     }
@@ -39826,13 +40024,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 = join14(rootPath, ...rel.split("/"));
+    const abs = join15(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(readFileSync15(abs, "utf8"), abs);
+      symbols = provider.extractSymbols(readFileSync16(abs, "utf8"), abs);
     } catch {
       continue;
     }
@@ -40176,7 +40374,7 @@ async function runIndexer(store, opts) {
         report.filesSkipped++;
         continue;
       }
-      source = readFileSync15(f.absPath, "utf8");
+      source = readFileSync16(f.absPath, "utf8");
     } catch {
       report.filesSkipped++;
       continue;
@@ -40255,7 +40453,7 @@ async function runIndexer(store, opts) {
     const depth = fileNode.relPath.split("/").length;
     if (depth !== 3) continue;
     try {
-      const pkg = JSON.parse(readFileSync15(fileNode.absPath, "utf8"));
+      const pkg = JSON.parse(readFileSync16(fileNode.absPath, "utf8"));
       if (!pkg.name) continue;
       const pkgDir = fileNode.relPath.replace(/\/package\.json$/, "");
       const candidates = [
@@ -40646,7 +40844,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 = join14(current, ent.name);
+    const abs = join15(current, ent.name);
     if (ent.isDirectory()) {
       await scan(root, abs, ignores, providers, out2);
     } else if (ent.isFile()) {
@@ -40705,7 +40903,7 @@ function gitListFiles(root, ignores, providers) {
   if (rels === null) return null;
   const out2 = [];
   for (const rel of rels) {
-    const abs = join14(root, rel);
+    const abs = join15(root, rel);
     let size;
     let mtimeMs;
     try {
@@ -40734,7 +40932,7 @@ function upsertFile(store, id, f, workspaceId2, skip) {
   if (existing && fileUnchanged(existing.attrs, f, skip)) return;
   let contentHash;
   try {
-    contentHash = createHash7("sha256").update(readFileSync15(f.absPath)).digest("hex");
+    contentHash = createHash7("sha256").update(readFileSync16(f.absPath)).digest("hex");
   } catch {
   }
   const carried = { ...existing?.attrs ?? {} };
@@ -45116,43 +45314,43 @@ ${JSON.stringify(symbolNames, null, 2)}`);
 });
 
 // ../../packages/indexer/src/languages/tree-sitter-loader.ts
-import { fileURLToPath } from "node:url";
-import { dirname as dirname8, join as join15 } from "node:path";
-import { existsSync as existsSync16, readdirSync as readdirSync3 } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { dirname as dirname9, join as join16 } from "node:path";
+import { existsSync as existsSync17, readdirSync as readdirSync3 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 function entryDir() {
   try {
     const url2 = import.meta?.url;
     if (typeof url2 === "string" && url2.length > 0) {
-      return dirname8(fileURLToPath(url2));
+      return dirname9(fileURLToPath2(url2));
     }
   } catch {
   }
-  return dirname8(process.execPath);
+  return dirname9(process.execPath);
 }
 function findWasmDir() {
   const here = entryDir();
-  const seaWasm = join15(here, "resources", "wasm");
-  if (existsSync16(join15(seaWasm, "tree-sitter-typescript.wasm"))) return seaWasm;
+  const seaWasm = join16(here, "resources", "wasm");
+  if (existsSync17(join16(seaWasm, "tree-sitter-typescript.wasm"))) return seaWasm;
   let dir = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const flat = join15(
+    const flat = join16(
       dir,
       "node_modules",
       "@vscode",
       "tree-sitter-wasm",
       "wasm"
     );
-    if (existsSync16(join15(flat, "tree-sitter-typescript.wasm"))) return flat;
-    dir = dirname8(dir);
+    if (existsSync17(join16(flat, "tree-sitter-typescript.wasm"))) return flat;
+    dir = dirname9(dir);
   }
   let root = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const pnpmDir = join15(root, "node_modules", ".pnpm");
-    if (existsSync16(pnpmDir)) {
+    const pnpmDir = join16(root, "node_modules", ".pnpm");
+    if (existsSync17(pnpmDir)) {
       for (const entry of readdirSync3(pnpmDir)) {
         if (entry.startsWith("@vscode+tree-sitter-wasm@")) {
-          const candidate = join15(
+          const candidate = join16(
             pnpmDir,
             entry,
             "node_modules",
@@ -45160,13 +45358,13 @@ function findWasmDir() {
             "tree-sitter-wasm",
             "wasm"
           );
-          if (existsSync16(join15(candidate, "tree-sitter-typescript.wasm"))) {
+          if (existsSync17(join16(candidate, "tree-sitter-typescript.wasm"))) {
             return candidate;
           }
         }
       }
     }
-    root = dirname8(root);
+    root = dirname9(root);
   }
   throw new Error(
     "@vscode/tree-sitter-wasm grammar files not found \u2014 is the package installed?"
@@ -45174,33 +45372,33 @@ function findWasmDir() {
 }
 function findRuntimeDir() {
   const here = entryDir();
-  const seaRuntime = join15(here, "resources", "wasm");
-  if (existsSync16(join15(seaRuntime, "web-tree-sitter.wasm"))) return seaRuntime;
+  const seaRuntime = join16(here, "resources", "wasm");
+  if (existsSync17(join16(seaRuntime, "web-tree-sitter.wasm"))) return seaRuntime;
   let dir = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const flat = join15(dir, "node_modules", "web-tree-sitter");
-    if (existsSync16(join15(flat, "web-tree-sitter.wasm"))) return flat;
-    dir = dirname8(dir);
+    const flat = join16(dir, "node_modules", "web-tree-sitter");
+    if (existsSync17(join16(flat, "web-tree-sitter.wasm"))) return flat;
+    dir = dirname9(dir);
   }
   let root = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const pnpmDir = join15(root, "node_modules", ".pnpm");
-    if (existsSync16(pnpmDir)) {
+    const pnpmDir = join16(root, "node_modules", ".pnpm");
+    if (existsSync17(pnpmDir)) {
       for (const entry of readdirSync3(pnpmDir)) {
         if (entry.startsWith("web-tree-sitter@")) {
-          const candidate = join15(
+          const candidate = join16(
             pnpmDir,
             entry,
             "node_modules",
             "web-tree-sitter"
           );
-          if (existsSync16(join15(candidate, "web-tree-sitter.wasm"))) {
+          if (existsSync17(join16(candidate, "web-tree-sitter.wasm"))) {
             return candidate;
           }
         }
       }
     }
-    root = dirname8(root);
+    root = dirname9(root);
   }
   throw new Error("web-tree-sitter runtime WASM not found");
 }
@@ -45211,7 +45409,7 @@ async function loadWebTreeSitter() {
     void err2;
   }
   const here = entryDir();
-  const seaResourceBase = join15(here, "resources", "_resolve.js");
+  const seaResourceBase = join16(here, "resources", "_resolve.js");
   const resourceRequire = createRequire2(seaResourceBase);
   return resourceRequire("web-tree-sitter");
 }
@@ -45226,9 +45424,9 @@ async function ensureTreeSitterReady() {
     await Parser2.init({
       locateFile: (name2) => {
         if (name2 === "tree-sitter.wasm" || name2 === "web-tree-sitter.wasm") {
-          return join15(runtime, name2);
+          return join16(runtime, name2);
         }
-        return join15(grammars, name2);
+        return join16(grammars, name2);
       }
     });
   })();
@@ -45240,7 +45438,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(join15(grammars, `${name2}.wasm`));
+  const lang = await languageClass.load(join16(grammars, `${name2}.wasm`));
   grammarCache.set(name2, lang);
   return lang;
 }
@@ -48145,7 +48343,7 @@ var init_src11 = __esm({
 // src/reconcile.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
 import { readdirSync as readdirSync4, statSync as statSync6 } from "node:fs";
-import { join as join16, relative as relative3, sep as sep2 } from "node:path";
+import { join as join17, relative as relative3, sep as sep2 } from "node:path";
 function indexerWouldScan(rel) {
   for (const seg of rel.split(/[\\/]/)) {
     if (seg.length === 0) continue;
@@ -48168,7 +48366,7 @@ function gitSourceFiles(root) {
   const out2 = [];
   for (const rel of stdout.split("\0")) {
     if (!rel || !SOURCE_RE.test(rel) || !indexerWouldScan(rel)) continue;
-    const abs = join16(root, rel);
+    const abs = join17(root, rel);
     if (IGNORED.test(abs)) continue;
     out2.push(abs);
   }
@@ -48183,7 +48381,7 @@ function* walkSource(dir) {
   }
   for (const e of entries) {
     const name2 = String(e.name);
-    const full = join16(dir, name2);
+    const full = join17(dir, name2);
     if (IGNORED.test(full)) continue;
     if (!indexerWouldScan(name2)) continue;
     if (e.isDirectory()) yield* walkSource(full);
@@ -48401,7 +48599,7 @@ __export(mcp_exports, {
   textMatches: () => textMatches,
   withLinks: () => withLinks
 });
-import { existsSync as existsSync17, readFileSync as readFileSync16 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync17 } from "node:fs";
 import { resolve as resolve4 } from "node:path";
 function collectEnrichmentPulls(store, opts = {}) {
   const pending = store.findLiveNodesByAttr("Solution", "enrichmentPending", 1).filter((s) => s.attrs["enrichmentPending"] === true).filter((s) => !opts.onlyUnsurfaced || s.attrs["enrichmentSurfaced"] !== true);
@@ -48447,7 +48645,7 @@ function takeEnrichmentNudge(store) {
 ` + items;
 }
 function takeDiscriminatorNudge(path3) {
-  if (!path3 || !existsSync17(path3)) return null;
+  if (!path3 || !existsSync18(path3)) return null;
   let shared;
   try {
     shared = openGraphStore({ path: path3 });
@@ -48714,10 +48912,10 @@ function showNode(store, node2, maxLines) {
   if (!relPath) return { found: false, reason: "no file owner for node" };
   const workspaceRoot = process.cwd();
   const absPath = resolve4(workspaceRoot, relPath);
-  if (!existsSync17(absPath)) {
+  if (!existsSync18(absPath)) {
     return { found: false, reason: `file not found on disk: ${absPath}` };
   }
-  const source = readFileSync16(absPath, "utf8");
+  const source = readFileSync17(absPath, "utf8");
   const attrs = node2.attrs;
   let startByte = attrs["bodyStartByte"] ?? attrs["startByte"];
   let endByte = attrs["bodyEndByte"] ?? attrs["endByte"];
@@ -48780,15 +48978,17 @@ function similarNodes(store, seed, limit) {
       hits: []
     };
   }
+  const versionOf = (attrs) => String(attrs?.["embeddingVersion"] ?? "hash-v1");
+  const seedVersion = versionOf(seed.attrs);
   const candidates = [];
   for (const n of store.selectNodes({
     labels: ["Problem", "Pattern", "Technique", "AntiPattern", "Function", "Method", "Class"],
-    attrs: ["test", "relPath"],
+    attrs: ["test", "relPath", "embeddingVersion"],
     where: [{ embedding: "present" }],
     withEmbedding: true
   })) {
     if (n.id === seed.id) continue;
-    if (n.embedding.length === seed.embedding.length) {
+    if (n.embedding.length === seed.embedding.length && versionOf(n.attrs) === seedVersion) {
       candidates.push(n);
     }
   }
@@ -49554,7 +49754,7 @@ var init_mcp = __esm({
           const local = causalChain(store, { seedId: id, direction: "both", maxHops, limit });
           try {
             const path3 = sharedStorePath();
-            if (!existsSync17(path3)) return { found: true, ...local };
+            if (!existsSync18(path3)) return { found: true, ...local };
             const shared = openGraphStore({ path: path3 });
             try {
               if (!shared.getNode(id)) return { found: true, ...local };
@@ -50213,7 +50413,7 @@ var init_mcp = __esm({
         inputSchema: { type: "object", properties: {} },
         handler: () => {
           const path3 = sharedStorePath();
-          if (!existsSync17(path3)) return { count: 0, pending: [] };
+          if (!existsSync18(path3)) return { count: 0, pending: [] };
           const shared = openGraphStore({ path: path3 });
           try {
             const pending = pendingAbstractions(shared);
@@ -50241,7 +50441,7 @@ var init_mcp = __esm({
         },
         handler: (args2) => {
           const path3 = sharedStorePath();
-          if (!existsSync17(path3)) return { count: 0, pending: [] };
+          if (!existsSync18(path3)) return { count: 0, pending: [] };
           const shared = openGraphStore({ path: path3 });
           try {
             const pending = pendingDiscriminators(shared, {
@@ -50285,7 +50485,7 @@ var init_mcp = __esm({
         },
         handler: (args2) => {
           const path3 = sharedStorePath();
-          if (!existsSync17(path3)) return { count: 0, routes: [] };
+          if (!existsSync18(path3)) return { count: 0, routes: [] };
           const shared = openGraphStore({ path: path3 });
           try {
             const result = triageOf(shared, {
@@ -50677,7 +50877,7 @@ __export(vfile_exports, {
   segmentsOf: () => segmentsOf
 });
 import { writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join17, resolve as resolve5, sep as sep3 } from "node:path";
+import { join as join18, resolve as resolve5, sep as sep3 } from "node:path";
 function segmentsOf(rawPath) {
   let p = rawPath.replace(/\\/g, "/");
   p = p.replace(/^.*\.errata\/g\//, "").replace(/^\/?g\//, "").replace(/^\/+/, "");
@@ -50751,7 +50951,7 @@ async function renderVFile(rawPath, store, ctx = {}) {
 }
 async function materializeVFile(rawPath, workspaceRoot, store, ctx = {}) {
   const segs = segmentsOf(rawPath);
-  const gRoot = join17(workspaceRoot, ".errata", "g");
+  const gRoot = join18(workspaceRoot, ".errata", "g");
   const abs = resolve5(gRoot, ...segs.length ? segs : ["index"]);
   if (abs !== gRoot && !abs.startsWith(gRoot + sep3)) {
     throw new Error(`refusing to materialize outside .errata/g: ${rawPath}`);
@@ -58178,25 +58378,25 @@ var init_tool_index = __esm({
 
 // src/outbox.ts
 import {
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync18,
   renameSync as renameSync2,
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync13
 } from "node:fs";
-import { join as join18 } from "node:path";
+import { join as join19 } 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 = join18(paths.outbox, `${Date.now()}-${id}.json`);
+  const file2 = join19(paths.outbox, `${Date.now()}-${id}.json`);
   writeFileSync13(file2, JSON.stringify(payload, null, 2), "utf8");
   return file2;
 }
 async function flushOutbox(paths, client, store) {
   ensureDir(paths.outbox);
-  const entries = existsSync18(paths.outbox) ? readdirSync5(paths.outbox) : [];
+  const entries = existsSync19(paths.outbox) ? readdirSync5(paths.outbox) : [];
   let uploaded = 0;
   let failed = 0;
   const quarantine = (abs, reason) => {
@@ -58207,10 +58407,10 @@ async function flushOutbox(paths, client, store) {
     }
   };
   for (const f of entries.filter((e) => e.endsWith(".json")).sort()) {
-    const abs = join18(paths.outbox, f);
+    const abs = join19(paths.outbox, f);
     let payload;
     try {
-      payload = JSON.parse(readFileSync17(abs, "utf8"));
+      payload = JSON.parse(readFileSync18(abs, "utf8"));
     } catch {
       failed++;
       quarantine(abs, "unparseable JSON");
@@ -58255,7 +58455,7 @@ async function flushOutbox(paths, client, store) {
       }
     }
   }
-  const remainingFiles = existsSync18(paths.outbox) ? readdirSync5(paths.outbox).filter((e) => e.endsWith(".json")) : [];
+  const remainingFiles = existsSync19(paths.outbox) ? readdirSync5(paths.outbox).filter((e) => e.endsWith(".json")) : [];
   return { uploaded, failed, remaining: remainingFiles.length };
 }
 var init_outbox = __esm({
@@ -78158,16 +78358,16 @@ __export(witness_ledger_exports, {
   summarizeWitnessLedger: () => summarizeWitnessLedger,
   witnessLedgerPath: () => witnessLedgerPath
 });
-import { appendFileSync as appendFileSync3, existsSync as existsSync28, readFileSync as readFileSync32, writeFileSync as writeFileSync22 } from "node:fs";
-import { join as join36 } from "node:path";
+import { appendFileSync as appendFileSync3, existsSync as existsSync29, readFileSync as readFileSync33, writeFileSync as writeFileSync22 } from "node:fs";
+import { join as join37 } from "node:path";
 function witnessLedgerPath(configDir) {
-  return join36(configDir, "witness-ledger.jsonl");
+  return join37(configDir, "witness-ledger.jsonl");
 }
 function appendWitnessLedger(configDir, entry) {
   const path3 = witnessLedgerPath(configDir);
   try {
     appendFileSync3(path3, JSON.stringify(entry) + "\n");
-    const lines = readFileSync32(path3, "utf8").split("\n").filter(Boolean);
+    const lines = readFileSync33(path3, "utf8").split("\n").filter(Boolean);
     if (lines.length > LEDGER_MAX_LINES) {
       writeFileSync22(path3, lines.slice(-Math.floor(LEDGER_MAX_LINES / 2)).join("\n") + "\n");
     }
@@ -78176,9 +78376,9 @@ function appendWitnessLedger(configDir, entry) {
 }
 function readWitnessLedger(configDir) {
   const path3 = witnessLedgerPath(configDir);
-  if (!existsSync28(path3)) return [];
+  if (!existsSync29(path3)) return [];
   try {
-    return readFileSync32(path3, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter((e) => typeof e.ts === "number" && typeof e.channel === "string");
+    return readFileSync33(path3, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter((e) => typeof e.ts === "number" && typeof e.channel === "string");
   } catch {
     return [];
   }
@@ -78617,12 +78817,12 @@ var init_report_render = __esm({
 
 // src/cli.ts
 init_src6();
-import { closeSync as closeSync3, existsSync as existsSync41, openSync as openSync3, readFileSync as readFileSync49, renameSync as renameSync10, statSync as statSync17, writeFileSync as writeFileSync34 } from "node:fs";
-import { join as join57, resolve as pathResolve2 } from "node:path";
+import { closeSync as closeSync3, existsSync as existsSync42, openSync as openSync3, readFileSync as readFileSync50, renameSync as renameSync10, statSync as statSync17, writeFileSync as writeFileSync34 } from "node:fs";
+import { join as join58, resolve as pathResolve2 } from "node:path";
 import { spawn as spawn5 } from "node:child_process";
 
 // src/daemon.ts
-import { existsSync as existsSync30, writeFileSync as writeFileSync25 } from "node:fs";
+import { existsSync as existsSync31, writeFileSync as writeFileSync25 } from "node:fs";
 
 // ../../node_modules/.pnpm/@hono+node-server@1.19.11_hono@4.12.34/node_modules/@hono/node-server/dist/index.mjs
 import { createServer as createServerHTTP } from "http";
@@ -79202,16 +79402,16 @@ init_config();
 init_lock();
 
 // src/replay-checkout.ts
-import { existsSync as existsSync19, readFileSync as readFileSync18, statSync as statSync7 } from "node:fs";
-import { dirname as dirname9, isAbsolute as isAbsolute4, join as join19, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync19, statSync as statSync7 } from "node:fs";
+import { dirname as dirname10, isAbsolute as isAbsolute4, join as join20, resolve as resolve6 } from "node:path";
 var REPLAY_MARKER = "errata-replay";
 function gitDirOf(cwd) {
-  for (let dir = resolve6(cwd); ; dir = dirname9(dir)) {
-    const dotGit = join19(dir, ".git");
-    if (existsSync19(dotGit)) {
+  for (let dir = resolve6(cwd); ; dir = dirname10(dir)) {
+    const dotGit = join20(dir, ".git");
+    if (existsSync20(dotGit)) {
       try {
         if (statSync7(dotGit).isDirectory()) return dotGit;
-        const m = /^gitdir:\s*(.+)$/m.exec(readFileSync18(dotGit, "utf8"));
+        const m = /^gitdir:\s*(.+)$/m.exec(readFileSync19(dotGit, "utf8"));
         if (!m) return null;
         const target = m[1].trim();
         return isAbsolute4(target) ? target : resolve6(dir, target);
@@ -79219,12 +79419,12 @@ function gitDirOf(cwd) {
         return null;
       }
     }
-    if (dirname9(dir) === dir) return null;
+    if (dirname10(dir) === dir) return null;
   }
 }
 function isReplayCheckout(cwd) {
   const gitDir = gitDirOf(cwd);
-  return gitDir != null && existsSync19(join19(gitDir, REPLAY_MARKER));
+  return gitDir != null && existsSync20(join20(gitDir, REPLAY_MARKER));
 }
 
 // src/activity-feed.ts
@@ -79332,8 +79532,8 @@ function knowledgeTag(label, attrs) {
 
 // src/engine.ts
 import { execFileSync as execFileSync6 } from "node:child_process";
-import { existsSync as existsSync29, statSync as statSync12, appendFileSync as appendFileSync4, readdirSync as readdirSync11, renameSync as renameSync5, readFileSync as readFileSync34, writeFileSync as writeFileSync24 } from "node:fs";
-import { basename as basename8, join as join38, relative as relative6, sep as sep5 } from "node:path";
+import { existsSync as existsSync30, statSync as statSync12, appendFileSync as appendFileSync4, readdirSync as readdirSync11, renameSync as renameSync5, readFileSync as readFileSync35, writeFileSync as writeFileSync24 } from "node:fs";
+import { basename as basename8, join as join39, relative as relative6, sep as sep5 } from "node:path";
 
 // src/coalesced-file-pass.ts
 function createCoalescedFilePass(delayMs, run3, onError) {
@@ -79378,7 +79578,7 @@ function createCoalescedFilePass(delayMs, run3, onError) {
 // src/source-watcher.ts
 import { EventEmitter as EventEmitter2 } from "node:events";
 import { readdirSync as readdirSync6, statSync as statSync8, watch as watch2 } from "node:fs";
-import { join as join22, sep as sep4 } from "node:path";
+import { join as join23, sep as sep4 } from "node:path";
 
 // ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -80109,9 +80309,9 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname22 = sysPath.dirname(file2);
+    const dirname23 = sysPath.dirname(file2);
     const basename11 = sysPath.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname22);
+    const parent = this.fsw._getWatchedDir(dirname23);
     let prevStats = stats;
     if (parent.has(basename11))
       return;
@@ -80138,7 +80338,7 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error48) {
-          this.fsw._remove(dirname22, basename11);
+          this.fsw._remove(dirname23, basename11);
         }
       } else if (parent.has(basename11)) {
         const at = newStats.atimeMs;
@@ -81114,7 +81314,7 @@ var NativeSourceWatcher = class extends EventEmitter2 {
     }
     try {
       const h = watch2(target, { recursive: isDir, persistent: true }, (event, name2) => {
-        const path3 = isDir ? name2 ? join22(target, name2.toString()) : null : target;
+        const path3 = isDir ? name2 ? join23(target, name2.toString()) : null : target;
         if (!path3) {
           this.emit("raw", event, target, { watchedPath: target, filenameMissing: true });
           this.scheduleReconcile(target, isDir);
@@ -81180,7 +81380,7 @@ var NativeSourceWatcher = class extends EventEmitter2 {
         continue;
       }
       for (const entry of entries) {
-        const path3 = join22(dir, entry.name);
+        const path3 = join23(dir, entry.name);
         if (this.ignored(path3)) continue;
         if (entry.isDirectory()) dirs.push(path3);
         else if (entry.isFile()) add(path3);
@@ -81491,9 +81691,9 @@ init_src6();
 init_session_registry();
 
 // src/snapshot-reuse.ts
-import { readFileSync as readFileSync19, renameSync as renameSync3, statSync as statSync9, writeFileSync as writeFileSync14 } from "node:fs";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { dirname as dirname12, join as join23 } from "node:path";
+import { readFileSync as readFileSync20, renameSync as renameSync3, statSync as statSync9, writeFileSync as writeFileSync14 } from "node:fs";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { dirname as dirname13, join as join24 } from "node:path";
 function revisitFlagsUnchanged(store, held, flaggedNow) {
   if (held.anySeq === void 0 || held.revisitIds === void 0 || !store.changedAmong) return false;
   const watched = [.../* @__PURE__ */ new Set([...held.revisitIds, ...flaggedNow])];
@@ -81509,7 +81709,7 @@ function snapshotCodeIdentity(version3) {
   if (codeIdentityMemo === void 0) {
     let built = "unknown";
     try {
-      built = String(statSync9(fileURLToPath2(import.meta.url)).mtimeMs);
+      built = String(statSync9(fileURLToPath3(import.meta.url)).mtimeMs);
     } catch {
     }
     codeIdentityMemo = `${version3}@${built}`;
@@ -81517,11 +81717,11 @@ function snapshotCodeIdentity(version3) {
   return codeIdentityMemo;
 }
 function heldSnapshotPath(configDir) {
-  return join23(configDir, "snapshot-held.json");
+  return join24(configDir, "snapshot-held.json");
 }
 function loadHeldSnapshot(path3) {
   try {
-    const held = JSON.parse(readFileSync19(path3, "utf8"));
+    const held = JSON.parse(readFileSync20(path3, "utf8"));
     return typeof held?.key === "string" && typeof held.at === "number" ? held : null;
   } catch {
     return null;
@@ -81529,7 +81729,7 @@ function loadHeldSnapshot(path3) {
 }
 function saveHeldSnapshot(path3, held) {
   try {
-    const tmp = join23(dirname12(path3), `.${process.pid}.snapshot-held.tmp`);
+    const tmp = join24(dirname13(path3), `.${process.pid}.snapshot-held.tmp`);
     writeFileSync14(tmp, JSON.stringify(held));
     renameSync3(tmp, path3);
   } catch {
@@ -81725,8 +81925,8 @@ init_review2();
 
 // src/turn.ts
 init_checkout_root();
-import { closeSync as closeSync2, existsSync as existsSync20, fstatSync, openSync as openSync2, readdirSync as readdirSync7, readSync as readSync2, realpathSync as realpathSync2, statSync as statSync10 } from "node:fs";
-import { basename as basename6, delimiter, dirname as dirname13, join as join24, normalize as normalize3 } from "node:path";
+import { closeSync as closeSync2, existsSync as existsSync21, fstatSync, openSync as openSync2, readdirSync as readdirSync7, readSync as readSync2, realpathSync as realpathSync2, statSync as statSync10 } from "node:fs";
+import { basename as basename6, delimiter, dirname as dirname14, join as join25, normalize as normalize4 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 import { createHash as createHash16 } from "node:crypto";
 function completeJsonlPrefix(buf) {
@@ -82114,11 +82314,11 @@ function turnsSince(turns, mark) {
   return at >= 0 ? turns.slice(at + 1) : turns;
 }
 function claudeProjectDir(cwd, home = homedir4()) {
-  return join24(home, ".claude", "projects", cwd.replace(/[\\/:.]/g, "-"));
+  return join25(home, ".claude", "projects", cwd.replace(/[\\/:.]/g, "-"));
 }
 function recentTranscripts(cwd, opts = {}) {
   const dir = claudeProjectDir(cwd, opts.home ?? homedir4());
-  if (!existsSync20(dir)) return [];
+  if (!existsSync21(dir)) return [];
   let names;
   try {
     names = readdirSync7(dir);
@@ -82129,7 +82329,7 @@ function recentTranscripts(cwd, opts = {}) {
   const refs = [];
   for (const name2 of names) {
     if (!name2.endsWith(".jsonl")) continue;
-    const path3 = join24(dir, name2);
+    const path3 = join25(dir, name2);
     let mtimeMs;
     try {
       mtimeMs = statSync10(path3).mtimeMs;
@@ -82144,8 +82344,8 @@ function recentTranscripts(cwd, opts = {}) {
 }
 function subagentTranscripts(mainTranscriptPath, sessionId) {
   if (!mainTranscriptPath || !sessionId) return [];
-  const dir = join24(dirname13(mainTranscriptPath), sessionId, "subagents");
-  if (!existsSync20(dir)) return [];
+  const dir = join25(dirname14(mainTranscriptPath), sessionId, "subagents");
+  if (!existsSync21(dir)) return [];
   let names;
   try {
     names = readdirSync7(dir);
@@ -82155,7 +82355,7 @@ function subagentTranscripts(mainTranscriptPath, sessionId) {
   const refs = [];
   for (const name2 of names) {
     if (!name2.endsWith(".jsonl")) continue;
-    const path3 = join24(dir, name2);
+    const path3 = join25(dir, name2);
     let mtimeMs;
     try {
       mtimeMs = statSync10(path3).mtimeMs;
@@ -82169,13 +82369,13 @@ function subagentTranscripts(mainTranscriptPath, sessionId) {
 }
 function splitPathList(value, sep7 = delimiter) {
   if (!value) return [];
-  return value.split(sep7).map((d) => d.trim()).filter(Boolean).map((d) => normalize3(d));
+  return value.split(sep7).map((d) => d.trim()).filter(Boolean).map((d) => normalize4(d));
 }
 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(join24(env2["CODEX_HOME"], "sessions"));
-  roots.add(join24(home, ".codex", "sessions"));
+  if (env2["CODEX_HOME"]) roots.add(join25(env2["CODEX_HOME"], "sessions"));
+  roots.add(join25(home, ".codex", "sessions"));
   return [...roots];
 }
 function readCodexRolloutIdentity(path3) {
@@ -82229,7 +82429,7 @@ function codexRolloutsForCwd(cwd, opts = {}) {
   const owner = checkoutRootOf(cwd);
   const owners = /* @__PURE__ */ new Map();
   for (const root of codexSessionRoots(opts.env, opts.home)) {
-    if (!existsSync20(root)) {
+    if (!existsSync21(root)) {
       codexRolloutActivity.delete(root);
       continue;
     }
@@ -82247,7 +82447,7 @@ function codexRolloutsForCwd(cwd, opts = {}) {
         continue;
       }
       for (const name2 of names) {
-        const full = join24(dir, name2);
+        const full = join25(dir, name2);
         let st;
         try {
           st = statSync10(full);
@@ -82289,8 +82489,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(join24(env2["GEMINI_CLI_HOME"], ".gemini", "tmp"));
-  roots.add(join24(home, ".gemini", "tmp"));
+  if (env2["GEMINI_CLI_HOME"]) roots.add(join25(env2["GEMINI_CLI_HOME"], ".gemini", "tmp"));
+  roots.add(join25(home, ".gemini", "tmp"));
   return [...roots];
 }
 function geminiProjectHash(cwd) {
@@ -82330,7 +82530,7 @@ function geminiTranscriptsForCwd(cwd, opts = {}) {
   const hashes = geminiHashesFor(cwd);
   const out2 = [];
   for (const root of geminiSessionRoots(opts.env, opts.home)) {
-    if (!existsSync20(root)) continue;
+    if (!existsSync21(root)) continue;
     let slugs;
     try {
       slugs = readdirSync7(root);
@@ -82338,7 +82538,7 @@ function geminiTranscriptsForCwd(cwd, opts = {}) {
       continue;
     }
     for (const slug2 of slugs) {
-      const chats = join24(root, slug2, "chats");
+      const chats = join25(root, slug2, "chats");
       let names;
       try {
         names = readdirSync7(chats);
@@ -82347,7 +82547,7 @@ function geminiTranscriptsForCwd(cwd, opts = {}) {
       }
       for (const name2 of names) {
         if (!name2.startsWith("session-") || !name2.endsWith(".jsonl")) continue;
-        const full = join24(chats, name2);
+        const full = join25(chats, name2);
         let st;
         try {
           st = statSync10(full);
@@ -82367,8 +82567,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(join24(env2["XDG_DATA_HOME"], "opencode", "errata"));
-  roots.add(join24(home, ".local", "share", "opencode", "errata"));
+  if (env2["XDG_DATA_HOME"]) roots.add(join25(env2["XDG_DATA_HOME"], "opencode", "errata"));
+  roots.add(join25(home, ".local", "share", "opencode", "errata"));
   return [...roots];
 }
 function readOpencodeTranscriptDirectory(path3) {
@@ -82401,7 +82601,7 @@ function opencodeTranscriptsForCwd(cwd, opts = {}) {
   }
   const out2 = [];
   for (const root of opencodeSessionRoots(opts.env, opts.home)) {
-    if (!existsSync20(root)) continue;
+    if (!existsSync21(root)) continue;
     let names;
     try {
       names = readdirSync7(root);
@@ -82410,7 +82610,7 @@ function opencodeTranscriptsForCwd(cwd, opts = {}) {
     }
     for (const name2 of names) {
       if (!name2.endsWith(".jsonl")) continue;
-      const full = join24(root, name2);
+      const full = join25(root, name2);
       let st;
       try {
         st = statSync10(full);
@@ -82433,7 +82633,7 @@ init_src2();
 init_agent_signals();
 init_tool_index();
 init_src5();
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync15 } from "node:fs";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync15 } 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_RE2 = new RegExp(TAG_HANDLE_SOURCE, "gi");
@@ -83268,7 +83468,7 @@ function writePrimingHandles(path3, nodes, now = Date.now()) {
 }
 function readPrimingHandles(path3) {
   try {
-    return JSON.parse(readFileSync20(path3, "utf8"));
+    return JSON.parse(readFileSync21(path3, "utf8"));
   } catch {
     return {};
   }
@@ -83870,8 +84070,8 @@ ${conversation}` }]
 // src/constraint-backfill.ts
 init_src5();
 init_src2();
-import { existsSync as existsSync21, readFileSync as readFileSync21, readdirSync as readdirSync8, writeFileSync as writeFileSync16 } from "node:fs";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync22, readdirSync as readdirSync8, writeFileSync as writeFileSync16 } from "node:fs";
+import { join as join26 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 var BACKFILL_VERSION = 1;
 var EMPTY = {
@@ -83885,13 +84085,13 @@ var EMPTY = {
   recoverable: 0
 };
 function markerPath(configDir) {
-  return join25(configDir, "constraint-backfill.json");
+  return join26(configDir, "constraint-backfill.json");
 }
 function alreadyDone(configDir) {
   const p = markerPath(configDir);
-  if (!existsSync21(p)) return false;
+  if (!existsSync22(p)) return false;
   try {
-    const raw2 = JSON.parse(readFileSync21(p, "utf8"));
+    const raw2 = JSON.parse(readFileSync22(p, "utf8"));
     return raw2?.version === BACKFILL_VERSION;
   } catch {
     return false;
@@ -83901,7 +84101,7 @@ function replay(root) {
   const statements2 = /* @__PURE__ */ new Set();
   const citedByFix = /* @__PURE__ */ new Set();
   const dir = claudeProjectDir(root, homedir5());
-  if (!existsSync21(dir)) return { statements: statements2, citedByFix };
+  if (!existsSync22(dir)) return { statements: statements2, citedByFix };
   let names;
   try {
     names = readdirSync8(dir).filter((n) => n.endsWith(".jsonl"));
@@ -83911,7 +84111,7 @@ function replay(root) {
   for (const f of names) {
     let lines;
     try {
-      lines = readFileSync21(join25(dir, f), "utf8").split("\n");
+      lines = readFileSync22(join26(dir, f), "utf8").split("\n");
     } catch {
       continue;
     }
@@ -84038,8 +84238,8 @@ function backfillConstraintKind(store, opts) {
 // src/edge-repair.ts
 init_src();
 init_src5();
-import { existsSync as existsSync22, readFileSync as readFileSync22, writeFileSync as writeFileSync17 } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync23, readFileSync as readFileSync23, writeFileSync as writeFileSync17 } from "node:fs";
+import { join as join27 } from "node:path";
 function citeEdgeId(from, type, to) {
   return `edge_${digest({ from, type, to })}`.slice(0, 24);
 }
@@ -84054,13 +84254,13 @@ var EMPTY2 = {
   byType: {}
 };
 function markerPath2(configDir) {
-  return join26(configDir, "edge-repair.json");
+  return join27(configDir, "edge-repair.json");
 }
 function alreadyDone2(configDir) {
   const p = markerPath2(configDir);
-  if (!existsSync22(p)) return false;
+  if (!existsSync23(p)) return false;
   try {
-    return JSON.parse(readFileSync22(p, "utf8"))?.version === EDGE_REPAIR_VERSION;
+    return JSON.parse(readFileSync23(p, "utf8"))?.version === EDGE_REPAIR_VERSION;
   } catch {
     return false;
   }
@@ -84123,8 +84323,8 @@ function repairInvalidEdges(store, opts) {
 init_reconcile();
 
 // src/pass-ledger.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync23, readFileSync as readFileSync23, writeFileSync as writeFileSync18 } from "node:fs";
-import { join as join27 } from "node:path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync24, readFileSync as readFileSync24, writeFileSync as writeFileSync18 } from "node:fs";
+import { join as join28 } from "node:path";
 
 // src/isolate-census.ts
 var live3 = 0;
@@ -84155,7 +84355,7 @@ var HOUR_MS = 36e5;
 var TRIM_EVERY = 50;
 var appendsSinceTrim = /* @__PURE__ */ new Map();
 function passLedgerPath(configDir) {
-  return join27(configDir, "pass-ledger.jsonl");
+  return join28(configDir, "pass-ledger.jsonl");
 }
 function appendPassLedger(configDir, kind, durationMs, counts) {
   const path3 = passLedgerPath(configDir);
@@ -84187,7 +84387,7 @@ function appendPassLedger(configDir, kind, durationMs, counts) {
       return;
     }
     appendsSinceTrim.set(path3, 0);
-    const lines = readFileSync23(path3, "utf8").split("\n").filter(Boolean);
+    const lines = readFileSync24(path3, "utf8").split("\n").filter(Boolean);
     const keptByKind = /* @__PURE__ */ new Map();
     const tailHours = /* @__PURE__ */ new Map();
     const tailFloor = Date.now() - LEVEL_TAIL_DAYS * 24 * HOUR_MS;
@@ -84222,9 +84422,9 @@ function appendPassLedger(configDir, kind, durationMs, counts) {
 }
 function readPassLedger(configDir) {
   const path3 = passLedgerPath(configDir);
-  if (!existsSync23(path3)) return [];
+  if (!existsSync24(path3)) return [];
   try {
-    return readFileSync23(path3, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter(
+    return readFileSync24(path3, "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 {
@@ -84667,11 +84867,11 @@ init_outbox();
 init_src10();
 init_src();
 init_src2();
-import { readFileSync as readFileSync24 } from "node:fs";
-import { join as join28 } from "node:path";
+import { readFileSync as readFileSync25 } from "node:fs";
+import { join as join29 } from "node:path";
 function loadClaimIgnorePatterns(workspaceRoot) {
   try {
-    return readFileSync24(join28(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
+    return readFileSync25(join29(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
   } catch {
     return [];
   }
@@ -85054,9 +85254,9 @@ async function pullCloudTriage(shared, cloud, profile, limit = 50) {
 // src/retrieval-stack.ts
 init_src();
 import { execFileSync as execFileSync5 } from "node:child_process";
-import { existsSync as existsSync24, readFileSync as readFileSync25, statSync as statSync11 } from "node:fs";
+import { existsSync as existsSync25, readFileSync as readFileSync26, statSync as statSync11 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 var RETRIEVAL_STACK_CAP = 24;
 var MANIFEST_SCAN_CAP = 400;
 var RUNTIME_TOKENS = /* @__PURE__ */ new Set([
@@ -85346,51 +85546,51 @@ function mavenGroupIsSelfDisclosing(name2, selfTokens) {
 function loadRegistryPolicy(root, env2 = process.env, repoLocator) {
   const read2 = (p) => {
     try {
-      return readFileSync25(p, "utf8");
+      return readFileSync26(p, "utf8");
     } catch {
       return null;
     }
   };
   const texts = (...paths) => paths.map(read2).filter((t) => t !== null);
   const home = homedir6();
-  const npm = parseNpmrcPolicy(texts(join29(root, ".npmrc"), join29(home, ".npmrc")));
+  const npm = parseNpmrcPolicy(texts(join30(root, ".npmrc"), join30(home, ".npmrc")));
   const blocked = /* @__PURE__ */ new Set();
   if (!npm.defaultPublic) blocked.add("npm");
   if (pypiIndexIsPrivate(
     texts(
-      join29(root, "pip.conf"),
-      join29(root, "pip.ini"),
-      join29(root, "pyproject.toml"),
-      join29(root, "requirements.txt"),
-      join29(home, ".pip", "pip.conf"),
-      join29(home, ".config", "pip", "pip.conf"),
-      join29(env2["APPDATA"] ?? home, "pip", "pip.ini")
+      join30(root, "pip.conf"),
+      join30(root, "pip.ini"),
+      join30(root, "pyproject.toml"),
+      join30(root, "requirements.txt"),
+      join30(home, ".pip", "pip.conf"),
+      join30(home, ".config", "pip", "pip.conf"),
+      join30(env2["APPDATA"] ?? home, "pip", "pip.ini")
     )
   )) {
     blocked.add("pypi");
   }
   if (cargoRegistryIsPrivate(
     texts(
-      join29(root, ".cargo", "config.toml"),
-      join29(root, ".cargo", "config"),
-      join29(home, ".cargo", "config.toml"),
-      join29(home, ".cargo", "config")
+      join30(root, ".cargo", "config.toml"),
+      join30(root, ".cargo", "config"),
+      join30(home, ".cargo", "config.toml"),
+      join30(home, ".cargo", "config")
     )
   )) {
     blocked.add("cargo");
   }
   if (nugetSourcesArePrivate(
     texts(
-      join29(root, "NuGet.config"),
-      join29(root, "nuget.config"),
-      join29(root, "NuGet.Config"),
-      join29(env2["APPDATA"] ?? home, "NuGet", "NuGet.Config"),
-      join29(home, ".nuget", "NuGet", "NuGet.Config")
+      join30(root, "NuGet.config"),
+      join30(root, "nuget.config"),
+      join30(root, "NuGet.Config"),
+      join30(env2["APPDATA"] ?? home, "NuGet", "NuGet.Config"),
+      join30(home, ".nuget", "NuGet", "NuGet.Config")
     )
   )) {
     blocked.add("nuget");
   }
-  const goEnvFile = env2["GOENV"] ?? join29(env2["APPDATA"] ?? join29(home, ".config"), "go", "env");
+  const goEnvFile = env2["GOENV"] ?? join30(env2["APPDATA"] ?? join30(home, ".config"), "go", "env");
   const goEnvText = read2(goEnvFile) ?? "";
   const fromFile = ["GOPRIVATE", "GONOSUMDB", "GONOSUMCHECK"].map(
     (k) => new RegExp(`^${k}=(.*)$`, "m").exec(goEnvText)?.[1]
@@ -85401,10 +85601,10 @@ function loadRegistryPolicy(root, env2 = process.env, repoLocator) {
     env2["GONOSUMCHECK"],
     ...fromFile
   ]);
-  const gemfiles = texts(join29(root, "Gemfile"));
+  const gemfiles = texts(join30(root, "Gemfile"));
   if (gemSourceIsPrivate(gemfiles)) blocked.add("gem");
   if (mavenReposArePrivate(
-    texts(join29(root, "pom.xml"), join29(home, ".m2", "settings.xml"))
+    texts(join30(root, "pom.xml"), join30(home, ".m2", "settings.xml"))
   )) {
     blocked.add("maven");
   }
@@ -85571,8 +85771,8 @@ function readDirectDependencies(root) {
   const familiesSeen = /* @__PURE__ */ new Set();
   for (const c of LOCKFILES) {
     if (familiesSeen.has(c.family)) continue;
-    const p = join29(root, c.file);
-    if (!existsSync24(p)) continue;
+    const p = join30(root, c.file);
+    if (!existsSync25(p)) continue;
     try {
       const s = statSync11(p);
       stamps.push(`${c.file}:${s.mtimeMs}:${s.size}`);
@@ -85592,7 +85792,7 @@ function readDirectDependencies(root) {
   const direct = [];
   for (const { c, path: path3 } of found) {
     try {
-      direct.push(...c.parse(readFileSync25(path3, "utf8")).direct ?? []);
+      direct.push(...c.parse(readFileSync26(path3, "utf8")).direct ?? []);
     } catch {
     }
   }
@@ -85635,14 +85835,14 @@ function manifestPaths(root) {
     "project.godot"
   ];
   return {
-    paths: ROOT_MANIFESTS.filter((f) => existsSync24(join29(root, f))),
+    paths: ROOT_MANIFESTS.filter((f) => existsSync25(join30(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) => existsSync24(join29(root, f)))) return true;
+  if (WORKSPACE_MARKERS.some((f) => existsSync25(join30(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 };
@@ -85656,11 +85856,11 @@ function scanManifests(root) {
   const texts = /* @__PURE__ */ new Map();
   const stamps = [];
   for (const rel of paths) {
-    const abs = join29(root, rel);
+    const abs = join30(root, rel);
     try {
       const s = statSync11(abs);
       stamps.push(`${rel}:${s.mtimeMs}:${s.size}`);
-      texts.set(rel, readFileSync25(abs, "utf8"));
+      texts.set(rel, readFileSync26(abs, "utf8"));
     } catch {
     }
   }
@@ -85696,22 +85896,22 @@ function readRetrievalInputs(root, repoLocator) {
 }
 
 // src/git-sensor.ts
-import { existsSync as existsSync25, readFileSync as readFileSync26, watch as fsWatch } from "node:fs";
-import { join as join30 } from "node:path";
+import { existsSync as existsSync26, readFileSync as readFileSync27, watch as fsWatch } from "node:fs";
+import { join as join31 } from "node:path";
 function readFirstLine(path3) {
   try {
-    return readFileSync26(path3, "utf8").split(/\r?\n/, 1)[0].trim();
+    return readFileSync27(path3, "utf8").split(/\r?\n/, 1)[0].trim();
   } catch {
     return null;
   }
 }
 function readGitRefState(gitDir) {
-  const head2 = readFirstLine(join30(gitDir, "HEAD"));
+  const head2 = readFirstLine(join31(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(join30(gitDir, "refs", "heads", branch));
+    sha2 = readFirstLine(join31(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;
@@ -85719,13 +85919,13 @@ function readGitRefState(gitDir) {
   return {
     branch,
     sha: sha2,
-    mergeHeadExists: existsSync25(join30(gitDir, "MERGE_HEAD")),
-    origHeadExists: existsSync25(join30(gitDir, "ORIG_HEAD"))
+    mergeHeadExists: existsSync26(join31(gitDir, "MERGE_HEAD")),
+    origHeadExists: existsSync26(join31(gitDir, "ORIG_HEAD"))
   };
 }
 function shaFromPackedRefs(gitDir, ref) {
   try {
-    for (const line of readFileSync26(join30(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
+    for (const line of readFileSync27(join31(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
       const [sha2, name2] = line.split(/\s+/);
       if (name2 === ref && sha2) return sha2;
     }
@@ -85759,7 +85959,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
   const settle = () => {
     if (timer) clearTimeout(timer);
     timer = setTimeout(() => {
-      if (existsSync25(join30(gitDir, "index.lock"))) {
+      if (existsSync26(join31(gitDir, "index.lock"))) {
         settle();
         return;
       }
@@ -85770,7 +85970,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
     }, debounceMs);
   };
   for (const sub of ["HEAD", "logs/HEAD", "MERGE_HEAD", "ORIG_HEAD"]) {
-    const p = join30(gitDir, sub);
+    const p = join31(gitDir, sub);
     try {
       watchers.push(fsWatch(p, settle));
     } catch {
@@ -86000,8 +86200,8 @@ var TelemetryRecorder = class {
 };
 
 // src/file-activity.ts
-import { readFileSync as readFileSync28 } from "node:fs";
-import { join as join32 } from "node:path";
+import { readFileSync as readFileSync29 } from "node:fs";
+import { join as join33 } from "node:path";
 import { createHash as createHash17 } from "node:crypto";
 
 // ../../packages/privacy/src/patterns/credentials.ts
@@ -86753,8 +86953,8 @@ init_git_remote();
 // src/history-bundle.ts
 init_src();
 import { execFile as execFile3 } from "node:child_process";
-import { readFileSync as readFileSync27 } from "node:fs";
-import { join as join31 } from "node:path";
+import { readFileSync as readFileSync28 } from "node:fs";
+import { join as join32 } from "node:path";
 var DEFAULT_MAX_TOKENS = 6e3;
 var FILE_LIST_CAP = 60;
 var DIFF_FILE_CAP = 40;
@@ -86793,7 +86993,7 @@ function pathAllowedByFloor(path3) {
 function loadRepoIgnore(root, extraPatterns = []) {
   let source = "";
   try {
-    source = readFileSync27(join31(root, ".errataignore"), "utf8");
+    source = readFileSync28(join32(root, ".errataignore"), "utf8");
   } catch {
     source = "";
   }
@@ -87098,7 +87298,7 @@ function readActivityBranch(root) {
   try {
     const gitDir = resolveGitDir(root);
     if (!gitDir) return null;
-    const head2 = readFileSync28(join32(gitDir, "HEAD"), "utf8").trim();
+    const head2 = readFileSync29(join33(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 {
@@ -87255,21 +87455,21 @@ var FileActivityReporter = class {
 
 // src/skills.ts
 import {
-  existsSync as existsSync26,
+  existsSync as existsSync27,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync29,
+  readFileSync as readFileSync30,
   readdirSync as readdirSync9,
   unlinkSync as unlinkSync4,
   writeFileSync as writeFileSync19
 } from "node:fs";
-import { basename as basename7, join as join33 } from "node:path";
+import { basename as basename7, join as join34 } from "node:path";
 function skillFileName(id) {
   return `${id.replace(/[^A-Za-z0-9_.-]/g, "_")}.md`;
 }
 function readSkillManifest(manifestPath) {
-  if (!existsSync26(manifestPath)) return [];
+  if (!existsSync27(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync29(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync30(manifestPath, "utf8"));
     return (parsed.skills ?? []).map((s) => ({
       title: s.title ?? "",
       layer: s.layer ?? "technique",
@@ -87293,7 +87493,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
   for (const s of res.skills) {
     const fileName = skillFileName(s.id);
     keep.add(fileName);
-    writeFileSync19(join33(paths.skillsDir, fileName), s.markdown, "utf8");
+    writeFileSync19(join34(paths.skillsDir, fileName), s.markdown, "utf8");
     rows.push({
       id: s.id,
       title: s.title,
@@ -87306,7 +87506,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
     const fileName = skillFileName(p.id);
     if (keep.has(fileName)) continue;
     keep.add(fileName);
-    writeFileSync19(join33(paths.skillsDir, fileName), p.markdown, "utf8");
+    writeFileSync19(join34(paths.skillsDir, fileName), p.markdown, "utf8");
     rows.push({
       id: p.id,
       title: p.title,
@@ -87320,7 +87520,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
     if (!f.endsWith(".md")) continue;
     if (keep.has(basename7(f))) continue;
     try {
-      unlinkSync4(join33(paths.skillsDir, f));
+      unlinkSync4(join34(paths.skillsDir, f));
       pruned++;
     } catch {
     }
@@ -87338,22 +87538,22 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
 init_src2();
 import {
   cpSync,
-  existsSync as existsSync27,
+  existsSync as existsSync28,
   lstatSync,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync30,
+  readFileSync as readFileSync31,
   readdirSync as readdirSync10,
   rmSync as rmSync3,
   symlinkSync,
   writeFileSync as writeFileSync20
 } from "node:fs";
-import { join as join34 } from "node:path";
+import { join as join35 } from "node:path";
 var SKILL_NS = "errata-";
 var HARNESS_SKILL_DIRS = [
-  { configDir: ".claude", skillsDir: join34(".claude", "skills") },
+  { configDir: ".claude", skillsDir: join35(".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: join34(".cursor", "skills") }
+  { configDir: ".cursor", skillsDir: join35(".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";
@@ -87398,12 +87598,12 @@ function skillCiteHandle(s) {
   return priorHandle({ id: s.id, description: s.title });
 }
 function reconcileNamespaced(dir, keep) {
-  if (!existsSync27(dir)) return 0;
+  if (!existsSync28(dir)) return 0;
   let pruned = 0;
   for (const name2 of readdirSync10(dir)) {
     if (!name2.startsWith(SKILL_NS) || keep.has(name2)) continue;
     try {
-      rmSync3(join34(dir, name2), { recursive: true, force: true });
+      rmSync3(join35(dir, name2), { recursive: true, force: true });
       pruned++;
     } catch {
     }
@@ -87412,7 +87612,7 @@ function reconcileNamespaced(dir, keep) {
 }
 function linkOrCopy(linkPath, target) {
   try {
-    if (existsSync27(linkPath) || safeLstat(linkPath)) rmSync3(linkPath, { recursive: true, force: true });
+    if (existsSync28(linkPath) || safeLstat(linkPath)) rmSync3(linkPath, { recursive: true, force: true });
   } catch {
   }
   try {
@@ -87433,7 +87633,7 @@ function safeLstat(p) {
   }
 }
 function emitAndProjectSkills(root, skills) {
-  const agentsSkillsDir = join34(root, ".agents", "skills");
+  const agentsSkillsDir = join35(root, ".agents", "skills");
   mkdirSync8(agentsSkillsDir, { recursive: true });
   const slugs = [];
   const keep = /* @__PURE__ */ new Set();
@@ -87441,7 +87641,7 @@ function emitAndProjectSkills(root, skills) {
   for (const s of skills) {
     let body2;
     try {
-      body2 = readFileSync30(s.bodyPath, "utf8");
+      body2 = readFileSync31(s.bodyPath, "utf8");
     } catch {
       continue;
     }
@@ -87450,9 +87650,9 @@ function emitAndProjectSkills(root, skills) {
     keep.add(slug2);
     slugs.push(slug2);
     const description = deriveDescription(s.title, s.layer, body2);
-    mkdirSync8(join34(agentsSkillsDir, slug2), { recursive: true });
+    mkdirSync8(join35(agentsSkillsDir, slug2), { recursive: true });
     writeFileSync20(
-      join34(agentsSkillsDir, slug2, "SKILL.md"),
+      join35(agentsSkillsDir, slug2, "SKILL.md"),
       renderSkillMd(slug2, description, body2, skillCiteHandle(s)),
       "utf8"
     );
@@ -87461,11 +87661,11 @@ function emitAndProjectSkills(root, skills) {
   reconcileNamespaced(agentsSkillsDir, keep);
   let projected = 0;
   for (const h of HARNESS_SKILL_DIRS) {
-    if (!existsSync27(join34(root, h.configDir))) continue;
-    const dir = join34(root, h.skillsDir);
+    if (!existsSync28(join35(root, h.configDir))) continue;
+    const dir = join35(root, h.skillsDir);
     mkdirSync8(dir, { recursive: true });
     for (const slug2 of slugs) {
-      linkOrCopy(join34(dir, slug2), join34(agentsSkillsDir, slug2));
+      linkOrCopy(join35(dir, slug2), join35(agentsSkillsDir, slug2));
       projected++;
     }
     reconcileNamespaced(dir, keep);
@@ -87474,15 +87674,15 @@ function emitAndProjectSkills(root, skills) {
   return { slugs, emitted, projected };
 }
 function emitInputsFromManifest(erretaDir, manifestPath) {
-  if (!existsSync27(manifestPath)) return [];
+  if (!existsSync28(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync30(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync31(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: join34(erretaDir, s.file)
+      bodyPath: join35(erretaDir, s.file)
     }));
   } catch {
     return [];
@@ -87496,10 +87696,10 @@ var GITIGNORE_LINES = [
   ".cursor/skills/errata-*/"
 ];
 function ensureSkillGitignore(root) {
-  const path3 = join34(root, ".gitignore");
+  const path3 = join35(root, ".gitignore");
   let current = "";
   try {
-    current = existsSync27(path3) ? readFileSync30(path3, "utf8") : "";
+    current = existsSync28(path3) ? readFileSync31(path3, "utf8") : "";
   } catch {
     return;
   }
@@ -87696,18 +87896,18 @@ init_paths();
 init_profile2();
 
 // src/witness-queue.ts
-import { readFileSync as readFileSync31, renameSync as renameSync4, writeFileSync as writeFileSync21 } from "node:fs";
-import { dirname as dirname14, join as join35 } from "node:path";
+import { readFileSync as readFileSync32, renameSync as renameSync4, writeFileSync as writeFileSync21 } from "node:fs";
+import { dirname as dirname15, join as join36 } 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 join35(workspaceConfigDir, "witness-queue.json");
+  return join36(workspaceConfigDir, "witness-queue.json");
 }
 function loadWitnessQueueWithLosses(path3) {
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync31(path3, "utf8"));
+    raw2 = JSON.parse(readFileSync32(path3, "utf8"));
   } catch (err2) {
     const absent = err2?.code === "ENOENT";
     return { queue: [], fileUnreadable: !absent, malformedEntries: 0 };
@@ -87720,7 +87920,7 @@ function loadWitnessQueueWithLosses(path3) {
 }
 function saveWitnessQueue(path3, queue) {
   try {
-    const tmp = join35(dirname14(path3), `.${Date.now()}.witness-queue.tmp`);
+    const tmp = join36(dirname15(path3), `.${Date.now()}.witness-queue.tmp`);
     writeFileSync21(tmp, JSON.stringify(queue), "utf8");
     renameSync4(tmp, path3);
   } catch {
@@ -88030,8 +88230,8 @@ function maybeFlushDigests() {
 
 // src/liveness-watch.ts
 init_src5();
-import { readFileSync as readFileSync33, writeFileSync as writeFileSync23 } from "node:fs";
-import { join as join37 } from "node:path";
+import { readFileSync as readFileSync34, writeFileSync as writeFileSync23 } from "node:fs";
+import { join as join38 } from "node:path";
 
 // src/loop-lag.ts
 var HEARTBEAT_MS = 500;
@@ -88163,11 +88363,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 join37(configDir, "liveness-alarms.json");
+  return join38(configDir, "liveness-alarms.json");
 }
 function loadAlarmState(path3) {
   try {
-    const raw2 = JSON.parse(readFileSync33(path3, "utf8"));
+    const raw2 = JSON.parse(readFileSync34(path3, "utf8"));
     return new Map(Object.entries(raw2).filter((e) => typeof e[1] === "number"));
   } catch {
     return /* @__PURE__ */ new Map();
@@ -88431,7 +88631,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.23-dev.4900" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.23-dev.4901" : "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;
@@ -88443,7 +88643,7 @@ var CODEX_SWEEP_LOOKBACK_MS = 10 * 6e4;
 function appendIdentityAudit(path3, record2, line) {
   if (!record2.accepted && record2.score <= 0) return;
   try {
-    if (existsSync29(path3) && statSync12(path3).size >= IDENTITY_AUDIT_MAX_BYTES) {
+    if (existsSync30(path3) && statSync12(path3).size >= IDENTITY_AUDIT_MAX_BYTES) {
       renameSync5(path3, `${path3}.1`);
     }
     appendFileSync4(path3, line);
@@ -88453,7 +88653,7 @@ function appendIdentityAudit(path3, record2, line) {
 var yieldToLoop = () => new Promise((r) => setImmediate(r));
 function loadTurnCursors(path3) {
   try {
-    const raw2 = JSON.parse(readFileSync34(path3, "utf8"));
+    const raw2 = JSON.parse(readFileSync35(path3, "utf8"));
     return new Map(
       Object.entries(raw2).map(([k, v]) => [k, typeof v === "string" ? v : String(v?.uuid ?? "")])
     );
@@ -88463,7 +88663,7 @@ function loadTurnCursors(path3) {
 }
 function loadTurnOffsets(path3) {
   try {
-    const raw2 = JSON.parse(readFileSync34(path3, "utf8"));
+    const raw2 = JSON.parse(readFileSync35(path3, "utf8"));
     const out2 = /* @__PURE__ */ new Map();
     for (const [k, v] of Object.entries(raw2)) {
       const off2 = typeof v === "object" && v !== null ? v.offset : void 0;
@@ -88476,7 +88676,7 @@ function loadTurnOffsets(path3) {
 }
 function loadTurnMoves(path3) {
   try {
-    const raw2 = JSON.parse(readFileSync34(path3, "utf8"));
+    const raw2 = JSON.parse(readFileSync35(path3, "utf8"));
     const out2 = /* @__PURE__ */ new Map();
     for (const [k, v] of Object.entries(raw2)) {
       const to = typeof v === "object" && v !== null ? v.movedTo : void 0;
@@ -88497,7 +88697,7 @@ function saveTurnCursors(path3, cursors, offsets, moves = /* @__PURE__ */ new Ma
   } catch {
   }
 }
-var turnCursorFile = (configDir) => join38(configDir, "turn-cursors.json");
+var turnCursorFile = (configDir) => join39(configDir, "turn-cursors.json");
 function turnCursorOnDisk(configDir, sessionId) {
   const path3 = turnCursorFile(configDir);
   const offset = loadTurnOffsets(path3).get(sessionId);
@@ -88529,7 +88729,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(join38(root, d) + sep5));
+      ignoredDirs = igOut.split("\0").filter(Boolean).map((d) => d.replace(/\/+$/, "")).filter((d) => !IGNORED_PATH.test(join39(root, d) + sep5));
     } catch {
     }
     const hasIgnoredChild = (dir) => ignoredDirs.some((ig) => ig.startsWith(dir + "/"));
@@ -88541,19 +88741,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(join38(root, f));
+        else targets.add(join39(root, f));
       }
       for (const c of children) {
-        if (IGNORED_PATH.test(join38(root, c) + sep5)) continue;
+        if (IGNORED_PATH.test(join39(root, c) + sep5)) continue;
         if (hasIgnoredChild(c)) addUnder(c);
-        else targets.add(join38(root, c));
+        else targets.add(join39(root, c));
       }
     };
     addUnder("");
     if (targets.size > 0) return [...targets];
   } catch {
   }
-  return readdirSync11(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !IGNORED_PATH.test(join38(root, String(e.name)) + sep5)).map((e) => join38(root, String(e.name)));
+  return readdirSync11(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !IGNORED_PATH.test(join39(root, String(e.name)) + sep5)).map((e) => join39(root, String(e.name)));
 }
 function createWorkspaceEngine(opts) {
   const paths = workspacePaths(opts.workspaceRoot);
@@ -88755,7 +88955,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) => join38(opts.workspaceRoot, p));
+        const abs = srcPaths.map((p) => join39(opts.workspaceRoot, p));
         try {
           const r = await runReindexPass(
             `git-reindex:${profile.name} (${abs.length} files)`,
@@ -88791,8 +88991,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 = join38(opts.workspaceRoot, ".git");
-    if (existsSync29(gitDir)) {
+    const gitDir = join39(opts.workspaceRoot, ".git");
+    if (existsSync30(gitDir)) {
       stopGit = startGitSensor(gitDir, (ev) => {
         void handleGitEvent(ev).catch((err2) => {
           console.warn("[errata] git event handler failed:", err2);
@@ -88853,7 +89053,7 @@ function createWorkspaceEngine(opts) {
     },
     onAlarms: (alarms) => {
       toastLivenessAlarms(
-        sharedAlarmToastGate(join38(globalDir(), "liveness-toasts.json")),
+        sharedAlarmToastGate(join39(globalDir(), "liveness-toasts.json")),
         { root: opts.workspaceRoot, name: profile.name },
         alarms,
         (body2, key) => notifyEvent("mechanism-stalled", body2, { key }),
@@ -88880,7 +89080,7 @@ function createWorkspaceEngine(opts) {
   let subagentBase = null;
   let subagentBaseVersion = 0;
   const subagentRenders = /* @__PURE__ */ new Map();
-  const sessions = createSessionRegistry({ originsPath: join38(paths.configDir, "session-origins.json") });
+  const sessions = createSessionRegistry({ originsPath: join39(paths.configDir, "session-origins.json") });
   const sessionRenders = /* @__PURE__ */ new Map();
   const selfCiteSkipsBySession = /* @__PURE__ */ new Map();
   const supersessionAsks = new SupersessionAsks();
@@ -88985,7 +89185,7 @@ function createWorkspaceEngine(opts) {
     const elicit = isEdgeElicitationEnabled();
     const snapOpts = {
       profile,
-      atCommit: readGitRefState(join38(opts.workspaceRoot, ".git")).sha ?? void 0,
+      atCommit: readGitRefState(join39(opts.workspaceRoot, ".git")).sha ?? void 0,
       reviewCount: pendingCount(paths),
       reviewUiUrl: opts.reviewUrl(),
       workingFile: workingFiles.mostRecent() ?? void 0,
@@ -89025,7 +89225,7 @@ function createWorkspaceEngine(opts) {
       );
       return null;
     }) : null;
-    if (snapOpts.atCommit !== (readGitRefState(join38(opts.workspaceRoot, ".git")).sha ?? void 0)) {
+    if (snapOpts.atCommit !== (readGitRefState(join39(opts.workspaceRoot, ".git")).sha ?? void 0)) {
       contextDirty = true;
       return;
     }
@@ -89071,10 +89271,10 @@ function createWorkspaceEngine(opts) {
     } catch (err2) {
       console.warn("[errata] context card failed:", err2.message?.slice(0, 120));
     }
-    const target = join38(opts.workspaceRoot, "AGENTS.md");
+    const target = join39(opts.workspaceRoot, "AGENTS.md");
     writeManagedBlock(target, { body: AGENTS_POINTER_BODY, stable: true, force: true });
     if (elicit) {
-      writePrimingHandles(join38(paths.configDir, "priming-handles.json"), [
+      writePrimingHandles(join39(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
@@ -89382,8 +89582,8 @@ function createWorkspaceEngine(opts) {
     const cached2 = subagentRenders.get(a.agentId);
     if (cached2?.key === key) return cached2.block;
     const elicit = isEdgeElicitationEnabled();
-    const handlesPath = join38(paths.configDir, "priming-handles.json");
-    const atCommit = readGitRefState(join38(opts.workspaceRoot, ".git")).sha ?? void 0;
+    const handlesPath = join39(paths.configDir, "priming-handles.json");
+    const atCommit = readGitRefState(join39(opts.workspaceRoot, ".git")).sha ?? void 0;
     const block = renderSubagentBlock({
       store,
       entry,
@@ -89438,7 +89638,7 @@ function createWorkspaceEngine(opts) {
     const cached2 = sessionRenders.get(sessionId);
     if (cached2?.key === key) return cached2.block;
     const elicit = isEdgeElicitationEnabled();
-    const atCommit = readGitRefState(join38(opts.workspaceRoot, ".git")).sha ?? void 0;
+    const atCommit = readGitRefState(join39(opts.workspaceRoot, ".git")).sha ?? void 0;
     const scoped = scopeSnapshot(structuredClone(subagentBase), (n) => !hiddenFrom(n, sessionId, sessions, now));
     delete scoped.workingFile;
     if (workingFile) {
@@ -89490,7 +89690,7 @@ function createWorkspaceEngine(opts) {
       ]
     };
     if (elicit && block.handleNodes.length) {
-      writePrimingHandles(join38(paths.configDir, "priming-handles.json"), block.handleNodes);
+      writePrimingHandles(join39(paths.configDir, "priming-handles.json"), block.handleNodes);
     }
     sessionRenders.delete(sessionId);
     sessionRenders.set(sessionId, { key, block });
@@ -89624,7 +89824,7 @@ function createWorkspaceEngine(opts) {
     let processedTurns = 0;
     const seqAtStart = store.currentIngestSeq();
     const elicit = isEdgeElicitationEnabled();
-    const handleMap = elicit ? readPrimingHandles(join38(paths.configDir, "priming-handles.json")) : {};
+    const handleMap = elicit ? readPrimingHandles(join39(paths.configDir, "priming-handles.json")) : {};
     const wsRoot = (opts.workspaceRoot ?? "").replace(/\\/g, "/");
     const toRel = (abs) => {
       const p = abs.replace(/\\/g, "/");
@@ -89847,7 +90047,7 @@ function createWorkspaceEngine(opts) {
             let anchorReadFailed = false;
             if (p.location) {
               try {
-                fileText = readFileSync34(join38(opts.workspaceRoot, p.location.path), "utf8");
+                fileText = readFileSync35(join39(opts.workspaceRoot, p.location.path), "utf8");
               } catch {
                 anchorReadFailed = true;
               }
@@ -90010,10 +90210,10 @@ function createWorkspaceEngine(opts) {
                 let enclosing = {};
                 if (p.location?.line !== void 0) {
                   try {
-                    const headSha = readGitRefState(join38(opts.workspaceRoot, ".git")).sha ?? void 0;
+                    const headSha = readGitRefState(join39(opts.workspaceRoot, ".git")).sha ?? void 0;
                     enclosing = {
                       line: p.location.line,
-                      fileText: readFileSync34(join38(opts.workspaceRoot, anchorPath), "utf8"),
+                      fileText: readFileSync35(join39(opts.workspaceRoot, anchorPath), "utf8"),
                       ...headSha ? { headSha } : {}
                     };
                   } catch {
@@ -90888,7 +91088,7 @@ B: ${b}`,
     try {
       const inputs = emitInputsFromManifest(paths.configDir, paths.skillsManifest);
       emitAndProjectSkills(opts.workspaceRoot, inputs);
-      writePrimingHandles(join38(paths.configDir, "priming-handles.json"), skillHandleNodes(inputs));
+      writePrimingHandles(join39(paths.configDir, "priming-handles.json"), skillHandleNodes(inputs));
     } catch (err2) {
       console.warn("[skills] agent-skills projection failed (non-fatal):", err2 instanceof Error ? err2.message : err2);
     }
@@ -91259,7 +91459,7 @@ B: ${b}`,
         console.log(
           "[errata] sync skipped \u2014 cloud sync consent is off (enable with `errata consent sync on`)"
         );
-        const pending = existsSync29(paths.outbox) ? readdirSync11(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
+        const pending = existsSync30(paths.outbox) ? readdirSync11(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
         return { uploaded: 0, failed: 0, remaining: pending };
       }
       if (!shipsFromWorkspace(opts.workspaceRoot)) {
@@ -91271,7 +91471,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 = existsSync29(paths.outbox) ? readdirSync11(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
+        const pending = existsSync30(paths.outbox) ? readdirSync11(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
         return { uploaded: 0, failed: 0, remaining: pending };
       }
       try {
@@ -91451,7 +91651,7 @@ async function startDaemon(opts) {
       );
       await engine.stop();
       try {
-        if (existsSync30(engine.paths.daemonLock)) {
+        if (existsSync31(engine.paths.daemonLock)) {
         }
       } catch {
       }
@@ -91652,8 +91852,8 @@ async function linkRegisteredWorkspaces(cfg, loggedInProfile = cfg.activeInstall
 }
 
 // src/edge-park.ts
-import { readFileSync as readFileSync35, renameSync as renameSync6, writeFileSync as writeFileSync26 } from "node:fs";
-import { dirname as dirname15, join as join39 } from "node:path";
+import { readFileSync as readFileSync36, renameSync as renameSync6, writeFileSync as writeFileSync26 } from "node:fs";
+import { dirname as dirname16, join as join40 } from "node:path";
 var EDGE_PARK_CAP = 2e3;
 var EDGE_PARK_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
 var EDGE_PARK_MAX_ATTEMPTS = 6;
@@ -91668,12 +91868,12 @@ function wireEdgeKey(from, type, to) {
   return JSON.stringify([from, type, to]);
 }
 function edgeParkPath(workspaceConfigDir, destinationKey) {
-  return join39(workspaceConfigDir, `edge-park.${destinationKey.slice(0, 16)}.json`);
+  return join40(workspaceConfigDir, `edge-park.${destinationKey.slice(0, 16)}.json`);
 }
 function loadEdgePark(path3) {
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync35(path3, "utf8"));
+    raw2 = JSON.parse(readFileSync36(path3, "utf8"));
   } catch {
     return [];
   }
@@ -91684,7 +91884,7 @@ function loadEdgePark(path3) {
 }
 function saveEdgePark(path3, queue) {
   try {
-    const tmp = join39(dirname15(path3), `.${Date.now()}.edge-park.tmp`);
+    const tmp = join40(dirname16(path3), `.${Date.now()}.edge-park.tmp`);
     writeFileSync26(tmp, JSON.stringify(queue), "utf8");
     renameSync6(tmp, path3);
   } catch {
@@ -92007,8 +92207,8 @@ function invalidateInstanceReceipt(current, destination, failedId, mirrorLegacy)
 // src/multi.ts
 init_dist();
 init_src5();
-import { existsSync as existsSync35, readFileSync as readFileSync41, writeFileSync as writeFileSync29 } from "node:fs";
-import { basename as basename10, dirname as dirname18, join as join48, resolve as pathResolve } from "node:path";
+import { existsSync as existsSync36, readFileSync as readFileSync42, writeFileSync as writeFileSync29 } from "node:fs";
+import { basename as basename10, dirname as dirname19, join as join49, resolve as pathResolve } from "node:path";
 
 // src/principle-sync.ts
 init_src5();
@@ -92036,8 +92236,8 @@ init_reconcile();
 
 // src/lockfile-auto.ts
 init_src();
-import { existsSync as existsSync31, readFileSync as readFileSync36 } from "node:fs";
-import { join as join40 } from "node:path";
+import { existsSync as existsSync32, readFileSync as readFileSync37 } from "node:fs";
+import { join as join41 } from "node:path";
 
 // src/package-index.ts
 init_src();
@@ -92210,11 +92410,11 @@ function runLockfilePass(opts) {
     { file: "package-lock.json", parse: parsePackageLockJson }
   ];
   for (const c of candidates) {
-    const p = join40(opts.root, c.file);
-    if (!existsSync31(p)) continue;
+    const p = join41(opts.root, c.file);
+    if (!existsSync32(p)) continue;
     let sbom;
     try {
-      sbom = c.parse(readFileSync36(p, "utf8"));
+      sbom = c.parse(readFileSync37(p, "utf8"));
     } catch {
       continue;
     }
@@ -92234,7 +92434,7 @@ init_src10();
 init_src();
 
 // src/contribution-ready.ts
-init_src3();
+init_src4();
 function cosine4(a, b) {
   if (a.length === 0 || a.length !== b.length) return 0;
   let dot = 0;
@@ -92248,7 +92448,9 @@ function cosine4(a, b) {
   return na === 0 || nb === 0 ? 0 : dot / (Math.sqrt(na) * Math.sqrt(nb));
 }
 function noveltyAgainst(node2, neighbors, opts = {}) {
-  const floor = opts.dedupCosine ?? NEMORI_DEDUP_COSINE;
+  const versionOf = (n) => String(n.attrs?.["embeddingVersion"] ?? "hash-v1");
+  const version3 = versionOf(node2);
+  const floor = opts.dedupCosine ?? cosineBandsFor(version3).dedup;
   const emb = node2.embedding ?? [];
   if (emb.length === 0) {
     return { ready: true, surprise: 1, topCosine: 0, reason: "no-embedding (fidelity-first)" };
@@ -92257,7 +92459,7 @@ function noveltyAgainst(node2, neighbors, opts = {}) {
   for (const other of neighbors) {
     if (other.id === node2.id) continue;
     const oe = other.embedding ?? [];
-    if (oe.length !== emb.length) continue;
+    if (oe.length !== emb.length || versionOf(other) !== version3) continue;
     const c = cosine4(emb, oe);
     if (c > topCosine) topCosine = c;
   }
@@ -92275,8 +92477,8 @@ init_profile2();
 init_session_registry();
 
 // src/public-symbols.ts
-import { readFileSync as readFileSync37, readdirSync as readdirSync12, existsSync as existsSync32 } from "node:fs";
-import { join as join41 } from "node:path";
+import { readFileSync as readFileSync38, readdirSync as readdirSync12, existsSync as existsSync33 } from "node:fs";
+import { join as join42 } from "node:path";
 var HEAD_BYTES = 8 * 1024;
 var INDEX_TTL_MS = 10 * 60 * 1e3;
 var MIN_SYMBOL_LEN = 4;
@@ -92309,20 +92511,20 @@ function bindingNames(clause) {
 function internalPackageNames(workspaceRoot) {
   const names = /* @__PURE__ */ new Set();
   const tryRead = (dir) => {
-    const pj = join41(dir, "package.json");
-    if (!existsSync32(pj)) return;
+    const pj = join42(dir, "package.json");
+    if (!existsSync33(pj)) return;
     try {
-      const name2 = JSON.parse(readFileSync37(pj, "utf8")).name;
+      const name2 = JSON.parse(readFileSync38(pj, "utf8")).name;
       if (typeof name2 === "string" && name2.length > 0) names.add(name2);
     } catch {
     }
   };
   tryRead(workspaceRoot);
   for (const group of ["packages", "apps"]) {
-    const groupDir = join41(workspaceRoot, group);
-    if (!existsSync32(groupDir)) continue;
+    const groupDir = join42(workspaceRoot, group);
+    if (!existsSync33(groupDir)) continue;
     try {
-      for (const entry of readdirSync12(groupDir)) tryRead(join41(groupDir, entry));
+      for (const entry of readdirSync12(groupDir)) tryRead(join42(groupDir, entry));
     } catch {
     }
   }
@@ -92341,7 +92543,7 @@ function publicSymbolIndex(store, workspaceRoot, deps = {}) {
   }
   const readHead = deps.readHead ?? ((absPath) => {
     try {
-      return readFileSync37(absPath, "utf8").slice(0, HEAD_BYTES);
+      return readFileSync38(absPath, "utf8").slice(0, HEAD_BYTES);
     } catch {
       return "";
     }
@@ -92361,7 +92563,7 @@ function publicSymbolIndex(store, workspaceRoot, deps = {}) {
   }
   const symbols = /* @__PURE__ */ new Set();
   for (const rel of files) {
-    const head2 = readHead(join41(workspaceRoot, rel));
+    const head2 = readHead(join42(workspaceRoot, rel));
     if (!head2) continue;
     for (const re of [NAMED_IMPORT_RE, REQUIRE_RE]) {
       re.lastIndex = 0;
@@ -93392,7 +93594,7 @@ init_config();
 
 // src/update.ts
 import { spawn as spawn2 } from "node:child_process";
-import { isAbsolute as isAbsolute6, join as join42 } from "node:path";
+import { isAbsolute as isAbsolute6, join as join43 } from "node:path";
 var PACKAGE_NAME = "@inerrata-corporation/errata";
 function parse3(v) {
   const m = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z][0-9A-Za-z.-]*))?/.exec(v.trim());
@@ -93541,7 +93743,7 @@ async function runInstalledHookRefresh() {
   let worst = 0;
   for (const harness of ["codex", "claude"]) {
     const code = await new Promise((resolve11) => {
-      const child = spawn2(process.execPath, [join42(root, PACKAGE_NAME, "errata.mjs"), "install-hooks", harness, "--refresh-existing"], {
+      const child = spawn2(process.execPath, [join43(root, PACKAGE_NAME, "errata.mjs"), "install-hooks", harness, "--refresh-existing"], {
         windowsHide: true,
         stdio: "inherit",
         timeout: 3e4
@@ -93690,12 +93892,12 @@ function landCloudEdge(store, e, from, to) {
 }
 
 // src/causal-edge-queue.ts
-import { readFileSync as readFileSync38, renameSync as renameSync7, writeFileSync as writeFileSync27 } from "node:fs";
-import { dirname as dirname16, join as join43 } from "node:path";
+import { readFileSync as readFileSync39, renameSync as renameSync7, writeFileSync as writeFileSync27 } from "node:fs";
+import { dirname as dirname17, join as join44 } from "node:path";
 var CAUSAL_EDGE_QUEUE_CAP = 5e3;
 var CAUSAL_EDGE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 function causalEdgeQueuePath(workspaceConfigDir) {
-  return join43(workspaceConfigDir, "causal-edge-queue.json");
+  return join44(workspaceConfigDir, "causal-edge-queue.json");
 }
 function parkedEdgeKey(e) {
   return `${e.from}|${e.type}|${e.to}`;
@@ -93703,7 +93905,7 @@ function parkedEdgeKey(e) {
 function loadCausalEdgeQueue(path3) {
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync38(path3, "utf8"));
+    raw2 = JSON.parse(readFileSync39(path3, "utf8"));
   } catch {
     return [];
   }
@@ -93714,7 +93916,7 @@ function loadCausalEdgeQueue(path3) {
 }
 function saveCausalEdgeQueue(path3, queue) {
   try {
-    const tmp = join43(dirname16(path3), `.${Date.now()}.causal-edge-queue.tmp`);
+    const tmp = join44(dirname17(path3), `.${Date.now()}.causal-edge-queue.tmp`);
     writeFileSync27(tmp, JSON.stringify(queue), "utf8");
     renameSync7(tmp, path3);
   } catch {
@@ -94146,9 +94348,9 @@ init_src11();
 init_src();
 import { execFile as execFile6 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
-import { extname as extname3, join as join44 } from "node:path";
+import { extname as extname3, join as join45 } from "node:path";
 import { createHash as createHash19 } from "node:crypto";
-import { readFileSync as readFileSync39 } from "node:fs";
+import { readFileSync as readFileSync40 } from "node:fs";
 
 // src/history-dependency-snapshot.ts
 init_src();
@@ -94271,7 +94473,7 @@ var Bounded = class extends Map {
 var DEFAULT_GIT = {};
 function readFileSafe(path3) {
   try {
-    return readFileSync39(path3, "utf8");
+    return readFileSync40(path3, "utf8");
   } catch {
     return "";
   }
@@ -94325,7 +94527,7 @@ async function syncHistoryRevisionPage(opts, resolve11) {
   const projectId = profile.projectId;
   const git3 = opts.git ?? (async (args2) => (await exec2("git", ["-C", root, ...args2], { windowsHide: true, maxBuffer: 8 * 1024 * 1024 })).stdout);
   const caches = cachesFor(opts.git ?? DEFAULT_GIT);
-  const ignoreKey = createHash19("sha256").update(JSON.stringify(profile.ignoreExtra ?? [])).update(readFileSafe(join44(root, ".errataignore"))).digest("hex").slice(0, 16);
+  const ignoreKey = createHash19("sha256").update(JSON.stringify(profile.ignoreExtra ?? [])).update(readFileSafe(join45(root, ".errataignore"))).digest("hex").slice(0, 16);
   const atCommit = (await git3(["rev-parse", "--verify", "HEAD"])).trim();
   if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(atCommit)) throw new Error("history revision is not a full Git object id");
   const oldCursor = profile.historyRevisionCursor;
@@ -94645,8 +94847,8 @@ ${await git3(["rev-list", "--parents", "-1", from])}`.split("\n").map((row) => r
 init_src7();
 init_src();
 import { execFile as execFile7 } from "node:child_process";
-import { readFileSync as readFileSync40 } from "node:fs";
-import { join as join45 } from "node:path";
+import { readFileSync as readFileSync41 } from "node:fs";
+import { join as join46 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 
 // src/history-walk.ts
@@ -95205,7 +95407,7 @@ async function defaultGit(root, args2) {
 function readIgnoreLines(root, profile) {
   let lines = [];
   try {
-    lines = readFileSync40(join45(root, ".errataignore"), "utf8").split("\n");
+    lines = readFileSync41(join46(root, ".errataignore"), "utf8").split("\n");
   } catch {
   }
   return [...lines, ...profile.ignoreExtra ?? []].map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
@@ -95785,8 +95987,8 @@ async function startHistoryStage(root, input, client, walk11 = {}) {
 init_cloud_auth();
 import { createHash as createHash20 } from "node:crypto";
 import { execFileSync as execFileSync7 } from "node:child_process";
-import { existsSync as existsSync33, writeFileSync as writeFileSync28 } from "node:fs";
-import { join as join46 } from "node:path";
+import { existsSync as existsSync34, writeFileSync as writeFileSync28 } from "node:fs";
+import { join as join47 } from "node:path";
 
 // src/device-poll.ts
 var THROTTLED_POLL_MIN_WAIT_MS = 11e3;
@@ -96245,8 +96447,8 @@ function applyLinkDecision(root, profile, config2, decision, now = Date.now) {
   delete nextProfile.projectLinkHold;
   let wroteIgnore = false;
   if (decision.writeIgnoreStarter !== false) {
-    const target = join46(root, ".errataignore");
-    if (!existsSync33(target)) {
+    const target = join47(root, ".errataignore");
+    if (!existsSync34(target)) {
       writeFileSync28(target, IGNORE_STARTER, "utf8");
       wroteIgnore = true;
     }
@@ -96260,13 +96462,13 @@ init_registry();
 
 // src/adopt.ts
 init_git_remote();
-import { existsSync as existsSync34 } from "node:fs";
-import { dirname as dirname17, join as join47 } from "node:path";
+import { existsSync as existsSync35 } from "node:fs";
+import { dirname as dirname18, join as join48 } from "node:path";
 function findGitRoot(absPath) {
   let dir = absPath;
   for (let depth = 0; depth < 64; depth++) {
-    if (existsSync34(join47(dir, ".git"))) return dir;
-    const parent = dirname17(dir);
+    if (existsSync35(join48(dir, ".git"))) return dir;
+    const parent = dirname18(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -96908,7 +97110,7 @@ async function startMultiDaemon(opts = {}) {
   };
   const sharedDbPath = sharedStorePath();
   ensureParent(sharedDbPath);
-  if (sharedDbPath !== ":memory:") excludeFromIndexing(dirname18(sharedDbPath));
+  if (sharedDbPath !== ":memory:") excludeFromIndexing(dirname19(sharedDbPath));
   await prepareStore(sharedDbPath, process.cwd(), "shared");
   const sharedStore = openGraphStore({ path: sharedDbPath });
   const bundledRun = import.meta.url.endsWith(".mjs");
@@ -97052,7 +97254,7 @@ async function startMultiDaemon(opts = {}) {
       held.push(...quarantined);
       let ignoreFile = "";
       try {
-        ignoreFile = readFileSync41(join48(r.root, ".errataignore"), "utf8");
+        ignoreFile = readFileSync42(join49(r.root, ".errataignore"), "utf8");
       } catch {
       }
       const retryInputs = JSON.stringify([
@@ -97120,7 +97322,7 @@ async function startMultiDaemon(opts = {}) {
     const id = entry.id;
     const castaliaPath = workspacePaths(entry.path).castalia;
     ensureParent(castaliaPath);
-    excludeFromIndexing(dirname18(castaliaPath));
+    excludeFromIndexing(dirname19(castaliaPath));
     await prepareStore(castaliaPath, entry.path, id);
     if (stopping) throw new Error("daemon stopping");
     const wsIdentity = identityFor(entry);
@@ -97633,10 +97835,10 @@ async function startMultiDaemon(opts = {}) {
   };
   const MISFILED_SWEEP_DELAY_MS = 2 * 6e4;
   const sweepMisfiled = async (rec) => {
-    const checkedPath = join48(workspacePaths(rec.root).configDir, "rehome-checked.json");
+    const checkedPath = join49(workspacePaths(rec.root).configDir, "rehome-checked.json");
     let checked;
     try {
-      checked = new Set(JSON.parse(readFileSync41(checkedPath, "utf8")));
+      checked = new Set(JSON.parse(readFileSync42(checkedPath, "utf8")));
     } catch {
       checked = /* @__PURE__ */ new Set();
     }
@@ -97755,7 +97957,7 @@ async function startMultiDaemon(opts = {}) {
         lastActiveAt = Math.max(lastActiveAt, rec.engine.lastActivityAt());
       } catch {
       }
-      const reason = retireDecision({ exists: existsSync35(rec.root), lastActiveAt, now });
+      const reason = retireDecision({ exists: existsSync36(rec.root), lastActiveAt, now });
       if (reason) void retireWorkspace(rec, reason);
     }
   };
@@ -99008,6 +99210,7 @@ async function startMultiDaemon(opts = {}) {
 
 // src/cli.ts
 init_src5();
+init_src4();
 init_profile2();
 init_git_remote();
 init_config();
@@ -99383,7 +99586,7 @@ import { spawnSync as spawnSync2 } from "node:child_process";
 
 // src/codex-runtime.ts
 import { readdirSync as readdirSync13, statSync as statSync13 } from "node:fs";
-import { join as join49 } from "node:path";
+import { join as join50 } from "node:path";
 function resolveCodexExecutable(options = {}) {
   const platform = options.platform ?? process.platform;
   const env2 = options.env ?? process.env;
@@ -99398,13 +99601,13 @@ function resolveCodexExecutable(options = {}) {
   };
   for (const dir of (env2["PATH"] ?? env2["Path"] ?? "").split(";")) {
     if (!dir.trim()) continue;
-    const path3 = join49(dir.trim().replace(/^"|"$/g, ""), "codex.exe");
+    const path3 = join50(dir.trim().replace(/^"|"$/g, ""), "codex.exe");
     if (fileTime(path3) !== null) return path3;
   }
   if (!env2["LOCALAPPDATA"]) return "codex";
-  const root = join49(env2["LOCALAPPDATA"], "OpenAI", "Codex", "bin");
+  const root = join50(env2["LOCALAPPDATA"], "OpenAI", "Codex", "bin");
   try {
-    const candidates = readdirSync13(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join49(root, entry.name, "codex.exe")).map((path3) => ({ path: path3, mtime: fileTime(path3) })).filter((candidate) => candidate.mtime !== null).sort((a, b) => b.mtime - a.mtime || a.path.localeCompare(b.path));
+    const candidates = readdirSync13(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join50(root, entry.name, "codex.exe")).map((path3) => ({ path: path3, mtime: fileTime(path3) })).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";
@@ -99543,14 +99746,14 @@ async function diagnoseInstallation(cfg, dependencies) {
 }
 
 // src/credential-scan.ts
-import { readFileSync as readFileSync43, statSync as statSync14 } from "node:fs";
+import { readFileSync as readFileSync44, statSync as statSync14 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { join as join51 } from "node:path";
+import { join as join52 } from "node:path";
 
 // src/claude-statusline.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync9, readFileSync as readFileSync42, writeFileSync as writeFileSync30 } from "node:fs";
+import { existsSync as existsSync37, mkdirSync as mkdirSync9, readFileSync as readFileSync43, writeFileSync as writeFileSync30 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { dirname as dirname19, join as join50 } from "node:path";
+import { dirname as dirname20, join as join51 } from "node:path";
 var STATUSLINE_RELAY_SOURCE = String.raw`// errata-managed: regenerated by errata init / install-hooks claude
 import { readFileSync } from 'node:fs';
 
@@ -99598,8 +99801,8 @@ function isSameInstall(value, relay) {
   return command.includes(relay.replace(/\\/g, "/").toLowerCase());
 }
 function userClaudeSettingsPath() {
-  const base = process.env["CLAUDE_CONFIG_DIR"] ?? join50(homedir7(), ".claude");
-  return join50(base, "settings.json");
+  const base = process.env["CLAUDE_CONFIG_DIR"] ?? join51(homedir7(), ".claude");
+  return join51(base, "settings.json");
 }
 function ensureUserStatusLine(opts) {
   const env2 = opts.env ?? process.env;
@@ -99607,22 +99810,22 @@ function ensureUserStatusLine(opts) {
   if (off2 === "0" || off2 === "off" || off2 === "false" || off2 === "no") return "disabled";
   const settingsPath = opts.userSettingsPath ?? userClaudeSettingsPath();
   let settings = {};
-  if (existsSync36(settingsPath)) {
+  if (existsSync37(settingsPath)) {
     try {
-      const parsed = JSON.parse(readFileSync42(settingsPath, "utf8"));
+      const parsed = JSON.parse(readFileSync43(settingsPath, "utf8"));
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return "unreadable";
       settings = parsed;
     } catch {
       return "unreadable";
     }
   }
-  const relay = join50(opts.relayDir, STATUSLINE_RELAY_FILE);
+  const relay = join51(opts.relayDir, STATUSLINE_RELAY_FILE);
   const keep = (value) => value !== void 0 && (!isErrataStatusLine(value) || !isSameInstall(value, relay));
   const ownMain = keep(settings["statusLine"]);
   const ownRows = keep(settings["subagentStatusLine"]);
   if (ownMain && ownRows) return "kept-own";
   mkdirSync9(opts.relayDir, { recursive: true });
-  if (!existsSync36(relay) || readFileSync42(relay, "utf8") !== STATUSLINE_RELAY_SOURCE) {
+  if (!existsSync37(relay) || readFileSync43(relay, "utf8") !== STATUSLINE_RELAY_SOURCE) {
     writeFileSync30(relay, STATUSLINE_RELAY_SOURCE, "utf8");
   }
   const nodePath = opts.nodePath ?? process.execPath;
@@ -99634,7 +99837,7 @@ function ensureUserStatusLine(opts) {
     return ownMain ? "kept-own" : "unchanged";
   }
   Object.assign(settings, next);
-  mkdirSync9(dirname19(settingsPath), { recursive: true });
+  mkdirSync9(dirname20(settingsPath), { recursive: true });
   writeFileSync30(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
   return "installed";
 }
@@ -99676,36 +99879,36 @@ function findCredentialLines(text) {
 function harnessConfigPaths(root) {
   const env2 = process.env;
   const home = homedir8();
-  const codexHome = env2["CODEX_HOME"] || join51(home, ".codex");
-  const geminiHome = join51(env2["GEMINI_CLI_HOME"] ?? home, ".gemini");
+  const codexHome = env2["CODEX_HOME"] || join52(home, ".codex");
+  const geminiHome = join52(env2["GEMINI_CLI_HOME"] ?? home, ".gemini");
   return [
     // Claude Code: user settings, `claude mcp add` (local/user scope), project.
     userClaudeSettingsPath(),
-    join51(env2["CLAUDE_CONFIG_DIR"] ?? home, ".claude.json"),
-    join51(root, ".claude", "settings.json"),
-    join51(root, ".claude", "settings.local.json"),
-    join51(root, ".mcp.json"),
+    join52(env2["CLAUDE_CONFIG_DIR"] ?? home, ".claude.json"),
+    join52(root, ".claude", "settings.json"),
+    join52(root, ".claude", "settings.local.json"),
+    join52(root, ".mcp.json"),
     // Codex
-    join51(codexHome, "config.toml"),
-    join51(root, ".codex", "config.toml"),
+    join52(codexHome, "config.toml"),
+    join52(root, ".codex", "config.toml"),
     // Gemini CLI
-    join51(geminiHome, "settings.json"),
-    join51(root, ".gemini", "settings.json"),
+    join52(geminiHome, "settings.json"),
+    join52(root, ".gemini", "settings.json"),
     // Cursor
-    join51(home, ".cursor", "mcp.json"),
-    join51(root, ".cursor", "mcp.json"),
+    join52(home, ".cursor", "mcp.json"),
+    join52(root, ".cursor", "mcp.json"),
     // VS Code (user profile mcp.json + workspace)
-    join51(vscodeUserDir(home, env2), "mcp.json"),
-    join51(root, ".vscode", "mcp.json"),
+    join52(vscodeUserDir(home, env2), "mcp.json"),
+    join52(root, ".vscode", "mcp.json"),
     // OpenCode (XDG on every platform; the daemon's installer writes the project one)
-    join51(env2["XDG_CONFIG_HOME"] ?? join51(home, ".config"), "opencode", "opencode.json"),
-    join51(root, "opencode.json")
+    join52(env2["XDG_CONFIG_HOME"] ?? join52(home, ".config"), "opencode", "opencode.json"),
+    join52(root, "opencode.json")
   ];
 }
 function vscodeUserDir(home, env2) {
-  if (process.platform === "win32") return join51(env2["APPDATA"] ?? join51(home, "AppData", "Roaming"), "Code", "User");
-  if (process.platform === "darwin") return join51(home, "Library", "Application Support", "Code", "User");
-  return join51(env2["XDG_CONFIG_HOME"] ?? join51(home, ".config"), "Code", "User");
+  if (process.platform === "win32") return join52(env2["APPDATA"] ?? join52(home, "AppData", "Roaming"), "Code", "User");
+  if (process.platform === "darwin") return join52(home, "Library", "Application Support", "Code", "User");
+  return join52(env2["XDG_CONFIG_HOME"] ?? join52(home, ".config"), "Code", "User");
 }
 function scanHarnessConfigs(paths, read2 = readBounded) {
   const findings = [];
@@ -99722,7 +99925,7 @@ function readBounded(path3) {
   try {
     const stat4 = statSync14(path3);
     if (!stat4.isFile() || stat4.size > MAX_SCAN_BYTES) return null;
-    return readFileSync43(path3, "utf8");
+    return readFileSync44(path3, "utf8");
   } catch {
     return null;
   }
@@ -99747,14 +99950,14 @@ function credentialHygieneCheck(scan2) {
 
 // src/codex-doctor.ts
 import { spawn as spawn4 } from "node:child_process";
-import { readFileSync as readFileSync45, statSync as statSync15 } from "node:fs";
-import { join as join53 } from "node:path";
+import { readFileSync as readFileSync46, statSync as statSync15 } from "node:fs";
+import { join as join54 } from "node:path";
 import { createInterface } from "node:readline";
 
 // src/codex-hooks.ts
-import { existsSync as existsSync37, mkdirSync as mkdirSync10, readFileSync as readFileSync44, renameSync as renameSync8, unlinkSync as unlinkSync5, writeFileSync as writeFileSync31 } from "node:fs";
+import { existsSync as existsSync38, mkdirSync as mkdirSync10, readFileSync as readFileSync45, renameSync as renameSync8, unlinkSync as unlinkSync5, writeFileSync as writeFileSync31 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
-import { join as join52 } from "node:path";
+import { join as join53 } from "node:path";
 
 // src/hook-commands.ts
 function hookCurlCommand(port, path3 = "/api/hook") {
@@ -100010,34 +100213,34 @@ function buildCodexRelaySource(workspaceRoot) {
 init_checkout_root();
 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 writeRelay(file2, source) {
-  if (existsSync37(file2) && readFileSync44(file2, "utf8") === source) return;
+  if (existsSync38(file2) && readFileSync45(file2, "utf8") === source) return;
   const temp = `${file2}.${process.pid}.tmp`;
   try {
     writeFileSync31(temp, source, { encoding: "utf8", mode: 384 });
     renameSync8(temp, file2);
   } finally {
-    if (existsSync37(temp)) unlinkSync5(temp);
+    if (existsSync38(temp)) unlinkSync5(temp);
   }
 }
 function refreshCodexRelay(root) {
-  const config2 = join52(root, ".codex", "config.toml");
-  if (!existsSync37(config2)) return "absent";
-  const existing = readFileSync44(config2, "utf8");
+  const config2 = join53(root, ".codex", "config.toml");
+  if (!existsSync38(config2)) return "absent";
+  const existing = readFileSync45(config2, "utf8");
   if (!existing.includes(CODEX_HOOKS_BEGIN) && !existing.includes(CODEX_HOOKS_END)) return "absent";
   replaceCodexHooks(existing, "");
-  const relay = join52(root, ".codex", "hooks", "errata-relay.mjs");
-  const prior = existsSync37(relay) ? readFileSync44(relay, "utf8") : "";
+  const relay = join53(root, ".codex", "hooks", "errata-relay.mjs");
+  const prior = existsSync38(relay) ? readFileSync45(relay, "utf8") : "";
   if (prior && !prior.startsWith("// errata-managed: regenerated by errata install-hooks codex")) {
     throw new Error("Codex relay is not Errata-managed; preserved it. Run errata install-hooks codex to explicitly replace it.");
   }
   const source = buildCodexRelaySource(checkoutRootOf(root));
   if (prior === source) return "current";
-  mkdirSync10(join52(root, ".codex", "hooks"), { recursive: true });
+  mkdirSync10(join53(root, ".codex", "hooks"), { recursive: true });
   writeRelay(relay, source);
   return "updated";
 }
-function hasCodexConfig(root, codexHome = process.env["CODEX_HOME"] || join52(homedir9(), ".codex")) {
-  return existsSync37(join52(root, ".codex")) || existsSync37(codexHome);
+function hasCodexConfig(root, codexHome = process.env["CODEX_HOME"] || join53(homedir9(), ".codex")) {
+  return existsSync38(join53(root, ".codex")) || existsSync38(codexHome);
 }
 function replaceCodexHooks(existing, block) {
   const begin = existing.indexOf(CODEX_HOOKS_BEGIN);
@@ -100053,14 +100256,14 @@ function replaceCodexHooks(existing, block) {
   return existing.trimEnd() + (existing.trim() ? "\n\n" : "") + block;
 }
 function writeCodexHooks(root, port, nodePath = process.execPath) {
-  const dir = join52(root, ".codex");
-  const file2 = join52(dir, "config.toml");
-  const relay = join52(dir, "hooks", "errata-relay.mjs");
+  const dir = join53(root, ".codex");
+  const file2 = join53(dir, "config.toml");
+  const relay = join53(dir, "hooks", "errata-relay.mjs");
   const block = buildCodexHooksToml(port, { nodePath, relayPath: relay });
-  const final = replaceCodexHooks(existsSync37(file2) ? readFileSync44(file2, "utf8") : "", block);
-  mkdirSync10(join52(dir, "hooks"), { recursive: true });
+  const final = replaceCodexHooks(existsSync38(file2) ? readFileSync45(file2, "utf8") : "", block);
+  mkdirSync10(join53(dir, "hooks"), { recursive: true });
   writeRelay(relay, buildCodexRelaySource(checkoutRootOf(root)));
-  if (!existsSync37(file2) || readFileSync44(file2, "utf8") !== final) writeFileSync31(file2, final, "utf8");
+  if (!existsSync38(file2) || readFileSync45(file2, "utf8") !== final) writeFileSync31(file2, final, "utf8");
   return file2;
 }
 
@@ -100069,7 +100272,7 @@ init_checkout_root();
 function inspectCodexRelay(cwd) {
   const root = nearestGitRoot(cwd) ?? cwd;
   try {
-    const source = readFileSync45(join53(root, ".codex", "hooks", "errata-relay.mjs"), "utf8");
+    const source = readFileSync46(join54(root, ".codex", "hooks", "errata-relay.mjs"), "utf8");
     if (source === buildCodexRelaySource(checkoutRootOf(root))) {
       return { id: "codex_relay", status: "pass", detail: "Installed Codex relay matches this Errata version" };
     }
@@ -100080,8 +100283,8 @@ function inspectCodexRelay(cwd) {
 function inspectCodexContext(cwd) {
   const root = checkoutRootOf(nearestGitRoot(cwd) ?? cwd);
   try {
-    const file2 = join53(root, ".errata", "context.md");
-    if (statSync15(file2).size <= 128 * 1024 && readFileSync45(file2, "utf8").trim()) {
+    const file2 = join54(root, ".errata", "context.md");
+    if (statSync15(file2).size <= 128 * 1024 && readFileSync46(file2, "utf8").trim()) {
       return { id: "codex_context", status: "pass", detail: "Saved workspace context is readable by the relay; this does not prove live daemon freshness" };
     }
   } catch {
@@ -100259,10 +100462,10 @@ function consolidationGapMs(lastPassMs, policy) {
 
 // src/codex-context-plugin.ts
 import { createHash as createHash21 } from "node:crypto";
-import { cpSync as cpSync2, existsSync as existsSync38, mkdirSync as mkdirSync11, readFileSync as readFileSync46, renameSync as renameSync9, writeFileSync as writeFileSync32 } from "node:fs";
+import { cpSync as cpSync2, existsSync as existsSync39, mkdirSync as mkdirSync11, readFileSync as readFileSync47, renameSync as renameSync9, writeFileSync as writeFileSync32 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
-import { join as join54 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { join as join55 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/error.js
 function getLineColFromPtr(string4, ptr) {
@@ -100959,7 +101162,7 @@ var NAME = "errata-context";
 var PREFIX2 = `./.errata/plugins/${NAME}/`;
 var object2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 function readText(file2) {
-  return existsSync38(file2) ? readFileSync46(file2, "utf8") : "";
+  return existsSync39(file2) ? readFileSync47(file2, "utf8") : "";
 }
 function writeChanged(file2, content) {
   if (readText(file2) === content) return;
@@ -100968,14 +101171,14 @@ function writeChanged(file2, content) {
   renameSync9(temp, file2);
 }
 function bundledContextPlugin() {
-  const packaged = fileURLToPath3(new URL("./resources/context-plugin/", import.meta.url));
-  if (existsSync38(join54(packaged, ".codex-plugin/plugin.json"))) return packaged;
-  return fileURLToPath3(new URL("../dist/resources/context-plugin/", import.meta.url));
+  const packaged = fileURLToPath4(new URL("./resources/context-plugin/", import.meta.url));
+  if (existsSync39(join55(packaged, ".codex-plugin/plugin.json"))) return packaged;
+  return fileURLToPath4(new URL("../dist/resources/context-plugin/", import.meta.url));
 }
 function refreshCodexContextPlugin(root) {
-  const file2 = join54(root, ".agents", "plugins", "marketplace.json");
-  if (!existsSync38(file2)) return false;
-  const marketplace = JSON.parse(readFileSync46(file2, "utf8"));
+  const file2 = join55(root, ".agents", "plugins", "marketplace.json");
+  if (!existsSync39(file2)) return false;
+  const marketplace = JSON.parse(readFileSync47(file2, "utf8"));
   const entries = Array.isArray(marketplace.plugins) ? marketplace.plugins : [];
   const entry = entries.map(object2).find((value) => value.name === NAME && String(object2(value.source).path).startsWith(PREFIX2));
   if (!entry) return false;
@@ -100986,24 +101189,24 @@ function refreshCodexContextPlugin(root) {
 function installCodexContextPlugin(root, options = {}) {
   const bundle = options.bundle ?? bundledContextPlugin();
   const manifest = JSON.parse(
-    readFileSync46(join54(bundle, ".codex-plugin/plugin.json"), "utf8")
+    readFileSync47(join55(bundle, ".codex-plugin/plugin.json"), "utf8")
   );
   if (manifest.name !== NAME || typeof manifest.version !== "string" || !/^[\w.-]+$/.test(manifest.version)) {
     throw new Error("Invalid bundled Errata Context manifest.");
   }
-  const checksums = readFileSync46(join54(bundle, "SHA256SUMS"), "utf8");
+  const checksums = readFileSync47(join55(bundle, "SHA256SUMS"), "utf8");
   for (const line of checksums.trim().split("\n")) {
     const match2 = /^([a-f0-9]{64})  ([\w./-]+)$/.exec(line);
     if (!match2 || match2[2].startsWith("/") || match2[2].split("/").includes("..")) {
       throw new Error("Invalid bundled Errata Context checksum manifest.");
     }
-    const actual = createHash21("sha256").update(readFileSync46(join54(bundle, match2[2]))).digest("hex");
+    const actual = createHash21("sha256").update(readFileSync47(join55(bundle, match2[2]))).digest("hex");
     if (actual !== match2[1])
       throw new Error(`Bundled Errata Context checksum mismatch: ${match2[2]}`);
   }
   const release = `${manifest.version}-${createHash21("sha256").update(checksums).digest("hex").slice(0, 12)}`;
-  const plugin = join54(root, ".errata", "plugins", NAME, release);
-  const marketplaceFile = join54(root, ".agents", "plugins", "marketplace.json");
+  const plugin = join55(root, ".errata", "plugins", NAME, release);
+  const marketplaceFile = join55(root, ".agents", "plugins", "marketplace.json");
   const priorMarketplace = readText(marketplaceFile);
   const marketplace = priorMarketplace ? JSON.parse(priorMarketplace) : {
     name: "errata-local",
@@ -101024,12 +101227,12 @@ function installCodexContextPlugin(root, options = {}) {
     );
   }
   const key = `${NAME}@${marketplace.name}`;
-  const configFile = join54(root, ".codex", "config.toml");
+  const configFile = join55(root, ".codex", "config.toml");
   const config2 = readText(configFile);
   const parsed = parse4(config2);
   const plugins = object2(parsed.plugins);
-  const codexHome = options.codexHome ?? process.env["CODEX_HOME"] ?? join54(homedir10(), ".codex");
-  const globalPlugins = object2(parse4(readText(join54(codexHome, "config.toml"))).plugins);
+  const codexHome = options.codexHome ?? process.env["CODEX_HOME"] ?? join55(homedir10(), ".codex");
+  const globalPlugins = object2(parse4(readText(join55(codexHome, "config.toml"))).plugins);
   const disabledGlobally = Object.entries(globalPlugins).some(
     ([name2, value]) => (name2 === NAME || name2.startsWith(`${NAME}@`)) && object2(value).enabled === false
   );
@@ -101053,13 +101256,13 @@ enabled = ${enabled}
   mkdirSync11(plugin, { recursive: true });
   cpSync2(bundle, plugin, { recursive: true });
   writeChanged(
-    join54(plugin, ".mcp.json"),
+    join55(plugin, ".mcp.json"),
     JSON.stringify(
       {
         mcpServers: {
           errata_context: {
             command: options.nodePath ?? process.execPath,
-            args: [join54(plugin, "dist", "mcp-server.mjs")],
+            args: [join55(plugin, "dist", "mcp-server.mjs")],
             env: { ERRATA_WORKSPACE: root, ERRATA_CONTEXT_VERSION: manifest.version }
           }
         }
@@ -101068,8 +101271,8 @@ enabled = ${enabled}
       2
     ) + "\n"
   );
-  mkdirSync11(join54(root, ".agents", "plugins"), { recursive: true });
-  mkdirSync11(join54(root, ".codex"), { recursive: true });
+  mkdirSync11(join55(root, ".agents", "plugins"), { recursive: true });
+  mkdirSync11(join55(root, ".codex"), { recursive: true });
   writeChanged(marketplaceFile, JSON.stringify(marketplace, null, 2) + "\n");
   writeChanged(configFile, nextConfig);
   return { plugin, enabled, marketplace: marketplaceFile };
@@ -101077,16 +101280,16 @@ enabled = ${enabled}
 
 // src/codex-hook-refresh.ts
 init_checkout_root();
-import { existsSync as existsSync39, readdirSync as readdirSync14, readFileSync as readFileSync47 } from "node:fs";
-import { dirname as dirname20, join as join55, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync40, readdirSync as readdirSync14, readFileSync as readFileSync48 } from "node:fs";
+import { dirname as dirname21, join as join56, resolve as resolve9 } from "node:path";
 init_registry();
 function codexHookRoots(roots) {
   const found = new Set(roots.map((root) => resolve9(root)));
   for (const root of [...found]) {
     const main2 = mainCheckoutOfWorktree(root) ?? root;
     found.add(main2);
-    const dir = join55(main2, ".git", "worktrees");
-    if (!existsSync39(dir)) continue;
+    const dir = join56(main2, ".git", "worktrees");
+    if (!existsSync40(dir)) continue;
     let names;
     try {
       names = readdirSync14(dir);
@@ -101095,7 +101298,7 @@ function codexHookRoots(roots) {
     }
     for (const name2 of names) {
       try {
-        const checkout = dirname20(readFileSync47(join55(dir, name2, "gitdir"), "utf8").trim());
+        const checkout = dirname21(readFileSync48(join56(dir, name2, "gitdir"), "utf8").trim());
         if (mainCheckoutOfWorktree(checkout) === main2) found.add(checkout);
       } catch {
       }
@@ -101118,14 +101321,14 @@ function refreshInstalledCodexRelays(roots = listWorkspaceEntries().map((entry)
 
 // src/claude-mods.ts
 import { createHash as createHash22 } from "node:crypto";
-import { cpSync as cpSync3, existsSync as existsSync40, mkdirSync as mkdirSync12, readFileSync as readFileSync48, readdirSync as readdirSync15, rmSync as rmSync4, statSync as statSync16, writeFileSync as writeFileSync33 } from "node:fs";
-import { delimiter as delimiter2, dirname as dirname21, join as join56, relative as relative7, resolve as resolve10, sep as sep6 } from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { cpSync as cpSync3, existsSync as existsSync41, mkdirSync as mkdirSync12, readFileSync as readFileSync49, readdirSync as readdirSync15, rmSync as rmSync4, statSync as statSync16, writeFileSync as writeFileSync33 } from "node:fs";
+import { delimiter as delimiter2, dirname as dirname22, join as join57, relative as relative7, resolve as resolve10, sep as sep6 } from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 var CLAUDE_PLUGIN_DIRS_ENV = "CLAUDE_CODE_PLUGIN_DIRS";
 var HASH_FILE = ".errata-mod-hash";
 function bundledClaudeModsDir() {
   const rel = import.meta.url.endsWith(".mjs") ? "./resources/claude-mods/" : "../claude-mods/";
-  return fileURLToPath4(new URL(rel, import.meta.url));
+  return fileURLToPath5(new URL(rel, import.meta.url));
 }
 function isEngineOwned(relPath) {
   const p = relPath.split(sep6).join("/");
@@ -101134,7 +101337,7 @@ function isEngineOwned(relPath) {
 function listFiles(root, dir = root) {
   const out2 = [];
   for (const name2 of readdirSync15(dir)) {
-    const abs = join56(dir, name2);
+    const abs = join57(dir, name2);
     if (isEngineOwned(relative7(root, abs))) continue;
     if (statSync16(abs).isDirectory()) out2.push(...listFiles(root, abs));
     else out2.push(abs);
@@ -101146,14 +101349,14 @@ function modHash(dir) {
   for (const abs of listFiles(dir).sort()) {
     h.update(relative7(dir, abs).split(sep6).join("/"));
     h.update("\0");
-    h.update(readFileSync48(abs));
+    h.update(readFileSync49(abs));
     h.update("\0");
   }
   return h.digest("hex");
 }
 function bundledMods(bundleDir) {
-  if (!existsSync40(bundleDir)) return [];
-  return readdirSync15(bundleDir).filter((name2) => existsSync40(join56(bundleDir, name2, ".claude-plugin", "plugin.json")));
+  if (!existsSync41(bundleDir)) return [];
+  return readdirSync15(bundleDir).filter((name2) => existsSync41(join57(bundleDir, name2, ".claude-plugin", "plugin.json")));
 }
 function sameDir(a, b) {
   const norm = (p) => resolve10(p).replace(/[\\/]+$/, "").toLowerCase();
@@ -101168,9 +101371,9 @@ function off(env2) {
   return v === "0" || v === "off" || v === "false" || v === "no";
 }
 function readSettings(path3) {
-  if (!existsSync40(path3)) return {};
+  if (!existsSync41(path3)) return {};
   try {
-    const parsed = JSON.parse(readFileSync48(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync49(path3, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
     return parsed;
   } catch {
@@ -101194,13 +101397,13 @@ function currentDirs(settings) {
   return raw2.split(delimiter2).map((s) => s.trim()).filter(Boolean);
 }
 function writeSettings(path3, settings) {
-  mkdirSync12(dirname21(path3), { recursive: true });
+  mkdirSync12(dirname22(path3), { recursive: true });
   writeFileSync33(path3, JSON.stringify(settings, null, 2) + "\n", "utf8");
 }
 function ensureClaudeMods(opts) {
   const env2 = opts.env ?? process.env;
   const settingsPath = opts.userSettingsPath ?? userClaudeSettingsPath();
-  const modsRoot = join56(opts.installRoot, "claude-mods");
+  const modsRoot = join57(opts.installRoot, "claude-mods");
   if (off(env2)) {
     const settings2 = readSettings(settingsPath);
     if (!settings2) return { kind: "unreadable" };
@@ -101217,11 +101420,11 @@ function ensureClaudeMods(opts) {
   let changed = false;
   const installed = [];
   for (const name2 of names) {
-    const src = join56(bundleDir, name2);
-    const dest = join56(modsRoot, name2);
+    const src = join57(bundleDir, name2);
+    const dest = join57(modsRoot, name2);
     const hash2 = modHash(src);
-    const hashFile = join56(dest, HASH_FILE);
-    if (!existsSync40(hashFile) || readFileSync48(hashFile, "utf8") !== hash2) {
+    const hashFile = join57(dest, HASH_FILE);
+    if (!existsSync41(hashFile) || readFileSync49(hashFile, "utf8") !== hash2) {
       rmSync4(dest, { recursive: true, force: true });
       cpSync3(src, dest, { recursive: true, filter: (p) => !isEngineOwned(relative7(src, p)) });
       writeFileSync33(hashFile, hash2, "utf8");
@@ -101655,9 +101858,9 @@ function resolveHookPort(explicit) {
       }
     }
   }
-  const settingsPath = join57(ROOT, ".claude", "settings.json");
+  const settingsPath = join58(ROOT, ".claude", "settings.json");
   try {
-    if (existsSync41(settingsPath)) return installedHookPort(readFileSync49(settingsPath, "utf8")) ?? 7891;
+    if (existsSync42(settingsPath)) return installedHookPort(readFileSync50(settingsPath, "utf8")) ?? 7891;
   } catch {
   }
   return 7891;
@@ -101682,14 +101885,14 @@ async function cmdInit() {
   if (!skipHooks) {
     console.log("");
     console.log("installing harness hooks...");
-    const { existsSync: existsSync42 } = await import("node:fs");
-    const { join: join58 } = await import("node:path");
+    const { existsSync: existsSync43 } = await import("node:fs");
+    const { join: join59 } = 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 (existsSync42(join58(ROOT, ".cursor"))) {
+    if (existsSync43(join59(ROOT, ".cursor"))) {
       try {
         await installCursorMcpConfig();
       } catch (err2) {
@@ -101905,12 +102108,12 @@ async function cmdStatus() {
     console.log(`    stack:     ${profile.stack.join(", ") || "(none)"}`);
     console.log(`    languages: ${profile.languages.join(", ") || "(none)"}`);
   }
-  console.log(`  graph db:  ${existsSync41(paths.castalia) ? "yes" : "no"} (${paths.castalia})`);
-  console.log(`  event log: ${existsSync41(paths.eventLog) ? "yes" : "no"} (${paths.eventLog})`);
+  console.log(`  graph db:  ${existsSync42(paths.castalia) ? "yes" : "no"} (${paths.castalia})`);
+  console.log(`  event log: ${existsSync42(paths.eventLog) ? "yes" : "no"} (${paths.eventLog})`);
   for (const line of captureStatusLines(summarizePassLedger(paths.configDir).get("capture"))) {
     console.log(`  capture:   ${line}`);
   }
-  if (existsSync41(paths.castalia)) {
+  if (existsSync42(paths.castalia)) {
     try {
       const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src5(), src_exports2));
       const store = openGraphStore2({ path: paths.castalia });
@@ -102911,11 +103114,11 @@ async function cmdInstallationProfile(args2) {
 }
 async function cmdReview() {
   const paths = workspacePaths(ROOT);
-  if (!existsSync41(paths.reviewQueue)) {
+  if (!existsSync42(paths.reviewQueue)) {
     console.log("(review queue empty)");
     return;
   }
-  const queue = JSON.parse(readFileSync49(paths.reviewQueue, "utf8"));
+  const queue = JSON.parse(readFileSync50(paths.reviewQueue, "utf8"));
   if (queue.length === 0) {
     console.log("(review queue empty)");
     return;
@@ -103517,9 +103720,8 @@ async function gatherRepo(store, ws) {
       next: { verb: "burst", arg: p.id, hint: "full causal chain" }
     });
   }
-  const SIM_FLOOR = 0.35;
-  const SIM_STRONG = 0.45;
-  const embedded = spineSrc.map((n, i2) => ({ i: i2, emb: embeddingOf(n) })).filter((x) => x.emb != null);
+  const versionOf = (n) => String(n.attrs["embeddingVersion"] ?? "hash-v1");
+  const embedded = spineSrc.map((n, i2) => ({ i: i2, emb: embeddingOf(n), version: versionOf(n) })).filter((x) => x.emb != null);
   const seenPair = new Set(spineEdges.map((e) => e.a < e.b ? `${e.a}-${e.b}` : `${e.b}-${e.a}`));
   const addImplied = (a, b) => {
     const key = a < b ? `${a}-${b}` : `${b}-${a}`;
@@ -103528,12 +103730,13 @@ async function gatherRepo(store, ws) {
     spineEdges.push({ a, b, kind: "implied" });
   };
   for (let x = 0; x < embedded.length; x++) {
+    const { relatedWeak, relatedStrong } = cosineBandsFor(embedded[x].version);
     let best = -1;
-    let bestSim = SIM_FLOOR;
+    let bestSim = relatedWeak;
     for (let y = 0; y < embedded.length; y++) {
-      if (y === x) continue;
+      if (y === x || embedded[y].version !== embedded[x].version) continue;
       const sim = cosine5(embedded[x].emb, embedded[y].emb);
-      if (sim >= SIM_STRONG) addImplied(embedded[x].i, embedded[y].i);
+      if (sim >= relatedStrong) addImplied(embedded[x].i, embedded[y].i);
       if (sim > bestSim) {
         bestSim = sim;
         best = embedded[y].i;
@@ -103615,7 +103818,7 @@ async function gatherRepo(store, ws) {
   };
 }
 async function gatherReportData(generatedAt) {
-  const { existsSync: existsSync42 } = await import("node:fs");
+  const { existsSync: existsSync43 } = 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";
@@ -103623,7 +103826,7 @@ async function gatherReportData(generatedAt) {
   for (const ws of listWorkspaces()) {
     if (ws.missing) continue;
     const dbPath = workspacePaths(ws.path).castalia;
-    if (!existsSync42(dbPath)) continue;
+    if (!existsSync43(dbPath)) continue;
     let store = null;
     try {
       store = openGraphStore2({ path: dbPath });
@@ -103667,8 +103870,8 @@ async function cmdReport(args2) {
   const outDir = workspacePaths(ROOT).configDir;
   mkdirSync13(outDir, { recursive: true });
   const files = renderReport2(data, { includeFutureVerbs });
-  for (const f of files) writeFileSync35(join57(outDir, f.name), f.html, "utf8");
-  const indexPath = join57(outDir, "report.html");
+  for (const f of files) writeFileSync35(join58(outDir, f.name), f.html, "utf8");
+  const indexPath = join58(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`
@@ -103797,24 +104000,24 @@ async function cmdInstallHooks(args2) {
   }
 }
 async function installOpencodePlugin(port) {
-  const { mkdirSync: mkdirSync13, existsSync: existsSync42, readFileSync: readFileSync50, writeFileSync: writeFileSync35 } = await import("node:fs");
-  const { join: join58 } = await import("node:path");
-  const dir = join58(ROOT, ".opencode", "plugin");
-  if (!existsSync42(dir)) mkdirSync13(dir, { recursive: true });
-  const file2 = join58(dir, "inerrata.js");
-  if (existsSync42(file2)) {
-    const head2 = readFileSync50(file2, "utf8").split("\n")[0] ?? "";
+  const { mkdirSync: mkdirSync13, existsSync: existsSync43, readFileSync: readFileSync51, writeFileSync: writeFileSync35 } = await import("node:fs");
+  const { join: join59 } = await import("node:path");
+  const dir = join59(ROOT, ".opencode", "plugin");
+  if (!existsSync43(dir)) mkdirSync13(dir, { recursive: true });
+  const file2 = join59(dir, "inerrata.js");
+  if (existsSync43(file2)) {
+    const head2 = readFileSync51(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);
     }
   }
   writeFileSync35(file2, buildOpencodePluginSource(port, { version: DAEMON_VERSION }), "utf8");
-  const cfgFile = join58(ROOT, "opencode.json");
+  const cfgFile = join59(ROOT, "opencode.json");
   let cfg = { $schema: "https://opencode.ai/config.json" };
-  if (existsSync42(cfgFile)) {
+  if (existsSync43(cfgFile)) {
     try {
-      cfg = JSON.parse(readFileSync50(cfgFile, "utf8"));
+      cfg = JSON.parse(readFileSync51(cfgFile, "utf8"));
     } catch {
       console.error(`refusing to touch invalid JSON at ${cfgFile} \u2014 fix it and re-run`);
       process.exit(2);
@@ -103859,15 +104062,15 @@ function installClaudeMods() {
   }
 }
 async function installClaudeHooks(port) {
-  const { mkdirSync: mkdirSync13, existsSync: existsSync42, readFileSync: readFileSync50, writeFileSync: writeFileSync35 } = await import("node:fs");
-  const { join: join58 } = await import("node:path");
-  const dir = join58(ROOT, ".claude");
-  if (!existsSync42(dir)) mkdirSync13(dir, { recursive: true });
-  const file2 = join58(dir, "settings.json");
+  const { mkdirSync: mkdirSync13, existsSync: existsSync43, readFileSync: readFileSync51, writeFileSync: writeFileSync35 } = await import("node:fs");
+  const { join: join59 } = await import("node:path");
+  const dir = join59(ROOT, ".claude");
+  if (!existsSync43(dir)) mkdirSync13(dir, { recursive: true });
+  const file2 = join59(dir, "settings.json");
   let settings = {};
-  if (existsSync42(file2)) {
+  if (existsSync43(file2)) {
     try {
-      settings = JSON.parse(readFileSync50(file2, "utf8"));
+      settings = JSON.parse(readFileSync51(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -103880,7 +104083,7 @@ async function installClaudeHooks(port) {
   console.log(`  ${ensureStatusLine(port)}`);
   console.log(`  ${installClaudeMods().line}`);
   await installClaudeMcpConfig();
-  const claudeMd = join58(ROOT, "CLAUDE.md");
+  const claudeMd = join59(ROOT, "CLAUDE.md");
   const recall = writeManagedBlock(claudeMd, { body: RECALL_FIRST_BLOCK });
   if (recall.kind === "collision") {
     console.warn(
@@ -103892,15 +104095,15 @@ async function installClaudeHooks(port) {
   console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
 }
 async function installClaudeMcpConfig() {
-  const { mkdirSync: mkdirSync13, existsSync: existsSync42, readFileSync: readFileSync50, writeFileSync: writeFileSync35 } = await import("node:fs");
-  const { join: join58, dirname: dirname22 } = await import("node:path");
-  const file2 = join58(ROOT, ".mcp.json");
-  const dir = dirname22(file2);
-  if (!existsSync42(dir)) mkdirSync13(dir, { recursive: true });
+  const { mkdirSync: mkdirSync13, existsSync: existsSync43, readFileSync: readFileSync51, writeFileSync: writeFileSync35 } = await import("node:fs");
+  const { join: join59, dirname: dirname23 } = await import("node:path");
+  const file2 = join59(ROOT, ".mcp.json");
+  const dir = dirname23(file2);
+  if (!existsSync43(dir)) mkdirSync13(dir, { recursive: true });
   let cfg = {};
-  if (existsSync42(file2)) {
+  if (existsSync43(file2)) {
     try {
-      cfg = JSON.parse(readFileSync50(file2, "utf8"));
+      cfg = JSON.parse(readFileSync51(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -103914,15 +104117,15 @@ async function installClaudeMcpConfig() {
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses / show / similar`);
 }
 async function installCursorMcpConfig() {
-  const { mkdirSync: mkdirSync13, existsSync: existsSync42, readFileSync: readFileSync50, writeFileSync: writeFileSync35 } = await import("node:fs");
-  const { join: join58 } = await import("node:path");
-  const dir = join58(ROOT, ".cursor");
-  if (!existsSync42(dir)) mkdirSync13(dir, { recursive: true });
-  const file2 = join58(dir, "mcp.json");
+  const { mkdirSync: mkdirSync13, existsSync: existsSync43, readFileSync: readFileSync51, writeFileSync: writeFileSync35 } = await import("node:fs");
+  const { join: join59 } = await import("node:path");
+  const dir = join59(ROOT, ".cursor");
+  if (!existsSync43(dir)) mkdirSync13(dir, { recursive: true });
+  const file2 = join59(dir, "mcp.json");
   let cfg = {};
-  if (existsSync42(file2)) {
+  if (existsSync43(file2)) {
     try {
-      cfg = JSON.parse(readFileSync50(file2, "utf8"));
+      cfg = JSON.parse(readFileSync51(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -103941,7 +104144,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(join57(hookRoot, "AGENTS.md"), {
+  const instructions = writeManagedBlock(join58(hookRoot, "AGENTS.md"), {
     body: AGENTS_POINTER_BODY,
     stable: true
   });
@@ -103989,10 +104192,10 @@ function refreshExistingClaudeHooks() {
   let ok = true;
   const roots = [...listWorkspaceEntries().map((entry) => entry.path), process.cwd()];
   for (const root of codexHookRoots(roots)) {
-    const file2 = join57(root, ".claude", "settings.json");
+    const file2 = join58(root, ".claude", "settings.json");
     try {
-      if (!existsSync41(file2) || isReplayCheckout(root)) continue;
-      const next = refreshClaudeHookSettings(readFileSync49(file2, "utf8"));
+      if (!existsSync42(file2) || isReplayCheckout(root)) continue;
+      const next = refreshClaudeHookSettings(readFileSync50(file2, "utf8"));
       if (next === null) continue;
       writeFileSync34(file2, next, "utf8");
       console.log(`updated existing Claude Code hooks \u2192 ${file2}`);
@@ -104406,9 +104609,9 @@ async function cmdDash(args2) {
       await yieldToLoop2();
       try {
         const items = selectDurableMemory(handle2.sharedStore, r.engine.profile, {
-          atCommit: readGitRefState(join57(r.root, ".git")).sha ?? void 0
+          atCommit: readGitRefState(join58(r.root, ".git")).sha ?? void 0
         });
-        const res = bleedRules(join57(r.root, ".claude", "rules"), items);
+        const res = bleedRules(join58(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` : "")