@inerrata-corporation/errata 2.0.2-dev.196 → 2.0.2-dev.204

package/errata.mjs

@@ -20982,10 +20982,13 @@ function buildSnapshot(opts) {
     episodeId: episodeId2,
     problems: problems2
   }));
-  const needsRevisit = listNeedsRevisit(
-    opts.store,
-    (opts.now ?? /* @__PURE__ */ new Date()).getTime()
-  ).slice(0, 10);
+  const revisitSeen = /* @__PURE__ */ new Set();
+  const needsRevisit = listNeedsRevisit(opts.store, (opts.now ?? /* @__PURE__ */ new Date()).getTime()).filter((r) => {
+    const key = `${r.label}:${r.description.trim().toLowerCase()}`;
+    if (revisitSeen.has(key)) return false;
+    revisitSeen.add(key);
+    return true;
+  }).slice(0, 5);
   const norm = (x) => x.toLowerCase().replace(/[^a-z0-9]+/g, "");
   const pkgBase = (x) => {
     const at = x.lastIndexOf("@");
@@ -21386,8 +21389,16 @@ ${RECALL_FIRST_BODY}`;
       // A standing design tension outranks an enrichment nudge (it prevents a wrong
       // decision) but yields to a live defect (which is actionable now).
       "recentConstraints",
-      "recentProblems",
-      "needsRevisit"
+      // `needsRevisit` used to sit LAST — the most protected band in the block. That
+      // inverted the block's whole purpose once the link-elicitation instruction (4,942
+      // chars, 55% of the budget, non-evictable) started competing for room: the
+      // budgeter drained all 8 Problems and all 4 Solutions and kept nine stale
+      // auto-close notices, so the agent was handed an instruction to cite `[handles]`
+      // with zero problem handles left to cite. A revisit flag is a maintenance nudge
+      // about something ALREADY closed; a live prior is the substrate every link verb
+      // needs. Problems outrank it now.
+      "needsRevisit",
+      "recentProblems"
     ];
     DEFAULT_AGENT_CONTEXT_BUDGET = 9e3;
   }
@@ -25259,15 +25270,15 @@ function triageBullet(ref) {
 }
 function linkBullet(ref) {
   return [
-    "  \u2022 a problem you flagged resembles prior knowledge \u2014 LINK it to the canonical priors, not just one:",
+    "  \u2022 you flagged a problem \u2014 LINK it, and do it ESPECIALLY when the finding feels novel.",
+    "    Work you just did feels specific to here; that feeling is why links go unwritten, and it is",
+    "    exactly backwards \u2014 a finding nobody can reach from anywhere else is one nobody reuses:",
     `    \xB7 (instance:[${ref}],[another-prior],\u2026) \u2014 the priors this problem is an instance of.`,
     "      Aim for ~3 DIFFERENT relevant priors; one link is weak, three triangulate it.",
     `    \xB7 ${TAG_EXAMPLE.pattern()} \u2014 name the general shape it instantiates (e.g. (pattern: unbounded`,
     "      queue growth under backpressure)) \u2014 this works with NO code anchor, and two agents naming",
-    "      the same pattern converge on one node. Cite a shown Pattern by handle: (pattern:[handle]).",
-    `    \xB7 ${TAG_EXAMPLE.domain()} \u2014 name the ABSTRACT AREA it's about (e.g. (domain: Observability),`,
-    "      (domain: Community Detection)). An abstract problem with no code anchor NEEDS this or it's",
-    "      an invisible island: the Domain is the topic other problems in the area cluster on. Title Case.",
+    "      the same pattern converge on one node. Naming the shape costs your finding nothing and is",
+    "      what lets a stranger hit it. Cite a shown Pattern by handle: (pattern:[handle]).",
     `    \xB7 ${TAG_EXAMPLE.package()} \u2014 the PUBLIC PACKAGE the problem is about, even when this`,
     "      workspace doesn't depend on it (e.g. (package: chokidar), (package: pypi/requests)) \u2014 a",
     "      public-registry anchor lets the knowledge cross to the collective; internal names stay private.",
@@ -25291,9 +25302,9 @@ function attemptBullet() {
   ].join("\n");
 }
 function buildAgentInstruction(opts = {}) {
-  const signals = opts.signals ?? ["prior", "problem", "fix", "constraint", "triage", "attempt", "link"];
+  const signals = opts.signals ?? ["prior", "problem", "domain", "fix", "constraint", "triage", "attempt", "link"];
   const ref = opts.referent ?? "its-handle";
-  const token = (s) => s === "problem" ? TAG_EXAMPLE.problem() : s === "constraint" ? TAG_EXAMPLE.constraint() : s === "attempt" ? TAG_EXAMPLE.tried() : s === "link" ? TAG_EXAMPLE.pattern() : TAG_EXAMPLE[s](ref);
+  const token = (s) => s === "problem" ? TAG_EXAMPLE.problem() : s === "constraint" ? TAG_EXAMPLE.constraint() : s === "attempt" ? TAG_EXAMPLE.tried() : s === "domain" ? TAG_EXAMPLE.domain() : s === "link" ? TAG_EXAMPLE.pattern() : TAG_EXAMPLE[s](ref);
   const head2 = `We tag the priors we show you with a short handle like [${opts.handleExample ?? "chokidar-glob"}]. This is a capture protocol, not optional notes: what you DON'T tag is silently lost \u2014 the tag is the ONLY thing recorded. Whenever one of these is true, wrap it inline in your prose (no fences, no extra calls). Tag every one you state; we filter downstream, so don't self-censor or batch:`;
   const tail = "Mid-turn text (between tool calls) can be dropped by the harness \u2014 if a tag above appeared only mid-turn, RESTATE it in your final message of the turn; the final message always survives.";
   return [
@@ -25359,6 +25370,22 @@ var init_agent_signals = __esm({
       constraint: "you made a design decision because requirements conflict or something's constrained \u2014 tag the tension, ESPECIALLY when your fix makes it 'only look' contradictory (a clean solution still hides a real trap the next agent needs)",
       triage: "you diagnosed a bug \u2014 SPLIT the symptom (what breaks \u2192 [!\u2026]) from the cause (the mechanism you'd change \u2192 (cause:\u2026)); if the line says WHY it breaks, it's a cause, not a problem",
       attempt: "you're attempting an approach, or an attempt didn't pan out \u2014 (tried: \u2026) / (failed: \u2026); a failed attempt rules out a path for the next agent",
+      // DOMAIN — promoted to a FIRST-CLASS signal (was nested inside linkBullet, whose
+      // lead-in gates on "a problem you flagged resembles prior knowledge"). Naming the
+      // area a problem is about is unconditional and has nothing to do with recognizing
+      // a prior, so that gate silently suppressed it: field census 2026-07-30 across 387
+      // sessions — `domain` in 10/194 tag-emitting sessions (5%) against `problem` in
+      // 124/194 (64%), and bimodal (the 10 that do emit average ~7 each), i.e. the
+      // syntax is fine and the trigger was never reached.
+      //
+      // The gloss carries the anti-performance framing Cycles 9–11 proved is the actual
+      // lever (the tag alone scored 0 = control; naming the bias and inverting it is
+      // what lifted capture). The bias here is the mirror of the constraint one: an
+      // agent that has just named a problem *precisely* feels the precision IS the
+      // contribution, so stating the general area reads as vague restatement — exactly
+      // when it matters most, because precise wording is what makes a problem
+      // unfindable to anyone who doesn't already share it.
+      domain: "you flagged a problem that isn't about one specific file \u2014 name the AREA it's about. Precision is not a substitute: the sharper your wording, the LESS anyone else will search for it, and an abstract problem with no area is an invisible island. Title Case",
       link: "the problem you flagged is an instance of priors/abstractions you can name \u2014 (instance:[h1],[h2],\u2026) / (pattern: \u2026) / (aids:[h]); rendered whole via linkBullet"
     };
   }
@@ -47172,12 +47199,12 @@ var init_report_render = __esm({
 
 // src/cli.ts
 init_src5();
-import { closeSync as closeSync2, existsSync as existsSync24, openSync as openSync2, readFileSync as readFileSync22, renameSync as renameSync3, statSync as statSync6 } from "node:fs";
-import { join as join26 } from "node:path";
+import { closeSync as closeSync2, existsSync as existsSync25, openSync as openSync2, readFileSync as readFileSync23, renameSync as renameSync3, statSync as statSync6 } from "node:fs";
+import { join as join27 } from "node:path";
 import { spawn as spawn3 } from "node:child_process";
 
 // src/daemon.ts
-import { existsSync as existsSync19, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync20, writeFileSync as writeFileSync16 } from "node:fs";
 
 // ../../node_modules/.pnpm/@hono+node-server@1.19.11_hono@4.12.8/node_modules/@hono/node-server/dist/index.mjs
 import { createServer as createServerHTTP } from "http";
@@ -47757,8 +47784,8 @@ init_config();
 
 // src/engine.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync18, statSync as statSync5, appendFileSync as appendFileSync2, readdirSync as readdirSync8, renameSync as renameSync2, readFileSync as readFileSync17, writeFileSync as writeFileSync14 } from "node:fs";
-import { join as join22, relative as relative6, sep as sep4 } from "node:path";
+import { existsSync as existsSync19, statSync as statSync5, appendFileSync as appendFileSync2, readdirSync as readdirSync9, renameSync as renameSync2, readFileSync as readFileSync18, writeFileSync as writeFileSync15 } from "node:fs";
+import { join as join23, relative as relative6, 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";
@@ -50541,6 +50568,147 @@ ${conversation}` }]
   };
 }
 
+// src/constraint-backfill.ts
+init_src4();
+init_src2();
+import { existsSync as existsSync13, readFileSync as readFileSync11, readdirSync as readdirSync6, writeFileSync as writeFileSync11 } from "node:fs";
+import { join as join16 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+var BACKFILL_VERSION = 1;
+var EMPTY = {
+  skipped: true,
+  stamped: 0,
+  detached: 0,
+  reopened: 0,
+  witnessed: 0,
+  cloudTwins: []
+};
+function markerPath(configDir) {
+  return join16(configDir, "constraint-backfill.json");
+}
+function alreadyDone(configDir) {
+  const p = markerPath(configDir);
+  if (!existsSync13(p)) return false;
+  try {
+    const raw2 = JSON.parse(readFileSync11(p, "utf8"));
+    return raw2?.version === BACKFILL_VERSION;
+  } catch {
+    return false;
+  }
+}
+function replay(root) {
+  const statements = /* @__PURE__ */ new Set();
+  const citedByFix = /* @__PURE__ */ new Set();
+  const dir = claudeProjectDir(root, homedir4());
+  if (!existsSync13(dir)) return { statements, citedByFix };
+  let names;
+  try {
+    names = readdirSync6(dir).filter((n) => n.endsWith(".jsonl"));
+  } catch {
+    return { statements, citedByFix };
+  }
+  for (const f of names) {
+    let lines;
+    try {
+      lines = readFileSync11(join16(dir, f), "utf8").split("\n");
+    } catch {
+      continue;
+    }
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let rec;
+      try {
+        rec = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (rec.type !== "assistant" || !Array.isArray(rec.message?.content)) continue;
+      for (const b of rec.message.content) {
+        if (b?.type !== "text" || typeof b.text !== "string") continue;
+        for (const tag of parseInlineTags(b.text)) {
+          if (tag.kind === "constraint" && tag.statement) statements.add(tag.statement);
+          if (tag.kind === "fix") {
+            const t = tag;
+            if (t.handle) citedByFix.add(t.handle);
+            if (t.threadId) citedByFix.add(t.threadId);
+          }
+        }
+      }
+    }
+  }
+  return { statements, citedByFix };
+}
+function backfillConstraintKind(store, opts) {
+  if (!opts.force && !opts.dryRun && alreadyDone(opts.configDir)) return EMPTY;
+  const { statements, citedByFix } = replay(opts.root);
+  const report = {
+    skipped: false,
+    stamped: 0,
+    detached: 0,
+    reopened: 0,
+    witnessed: 0,
+    cloudTwins: []
+  };
+  const seen = /* @__PURE__ */ new Set();
+  const work = [];
+  for (const statement of statements) {
+    const id = designProblemId(statement);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const node2 = store.getNode(id);
+    if (!node2 || node2.label !== "Problem") continue;
+    const isWitnessed = citedByFix.has(priorHandle(node2)) || citedByFix.has(id) || [...citedByFix].some((c) => c && id.startsWith(c));
+    const fabricated = [];
+    for (const e of store.outEdges(id, ["SOLVED_BY"])) {
+      const sol = store.getNode(e.to);
+      if (!sol) continue;
+      const auto = sol.description.startsWith(AUTO_MINT_PREFIX);
+      if (!auto && isWitnessed) report.witnessed++;
+      else fabricated.push(sol.id);
+    }
+    const stamp = node2.attrs["kind"] !== "constraint";
+    if (stamp) report.stamped++;
+    if (fabricated.length > 0) {
+      report.detached += fabricated.length;
+      report.reopened++;
+    }
+    const cloudNodeId = node2.attrs["cloudNodeId"];
+    if (typeof cloudNodeId === "string" && (stamp || fabricated.length > 0)) {
+      report.cloudTwins.push(cloudNodeId);
+    }
+    if (stamp || fabricated.length > 0) work.push({ id, fabricated, stamp });
+  }
+  if (opts.dryRun) return report;
+  store.transaction(() => {
+    for (const w of work) {
+      const node2 = store.getNode(w.id);
+      if (!node2) continue;
+      const attrs = { ...node2.attrs, kind: "constraint" };
+      if (w.fabricated.length > 0) {
+        delete attrs["resolvedAt"];
+        delete attrs["resolvedReason"];
+      }
+      store.updateNode(w.id, { attrs, lastUpdatedAt: opts.now });
+      for (const solId of w.fabricated) {
+        for (const e of store.outEdges(w.id, ["SOLVED_BY"])) {
+          if (e.to === solId) store.closeEdge(e.id, opts.now);
+        }
+        const sol = store.getNode(solId);
+        if (sol?.description.startsWith(AUTO_MINT_PREFIX)) store.closeNode(solId, opts.now);
+      }
+    }
+  });
+  try {
+    writeFileSync11(
+      markerPath(opts.configDir),
+      JSON.stringify({ version: BACKFILL_VERSION, at: opts.now, ...report, cloudTwins: report.cloudTwins.length }, null, 2),
+      "utf8"
+    );
+  } catch {
+  }
+  return report;
+}
+
 // src/engine.ts
 init_symbol_summaries();
 init_reconcile();
@@ -50739,11 +50907,11 @@ init_outbox();
 init_src8();
 init_src();
 init_src2();
-import { readFileSync as readFileSync11 } from "node:fs";
-import { join as join16 } from "node:path";
+import { readFileSync as readFileSync12 } from "node:fs";
+import { join as join17 } from "node:path";
 function loadClaimIgnorePatterns(workspaceRoot) {
   try {
-    return readFileSync11(join16(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
+    return readFileSync12(join17(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
   } catch {
     return [];
   }
@@ -51104,22 +51272,22 @@ async function pullCloudTriage(shared, cloud, profile, limit = 50) {
 }
 
 // src/git-sensor.ts
-import { existsSync as existsSync13, readFileSync as readFileSync12, watch as fsWatch } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync13, watch as fsWatch } from "node:fs";
+import { join as join18 } from "node:path";
 function readFirstLine(path2) {
   try {
-    return readFileSync12(path2, "utf8").split(/\r?\n/, 1)[0].trim();
+    return readFileSync13(path2, "utf8").split(/\r?\n/, 1)[0].trim();
   } catch {
     return null;
   }
 }
 function readGitRefState(gitDir) {
-  const head2 = readFirstLine(join17(gitDir, "HEAD"));
+  const head2 = readFirstLine(join18(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(join17(gitDir, "refs", "heads", branch));
+    sha2 = readFirstLine(join18(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;
@@ -51127,13 +51295,13 @@ function readGitRefState(gitDir) {
   return {
     branch,
     sha: sha2,
-    mergeHeadExists: existsSync13(join17(gitDir, "MERGE_HEAD")),
-    origHeadExists: existsSync13(join17(gitDir, "ORIG_HEAD"))
+    mergeHeadExists: existsSync14(join18(gitDir, "MERGE_HEAD")),
+    origHeadExists: existsSync14(join18(gitDir, "ORIG_HEAD"))
   };
 }
 function shaFromPackedRefs(gitDir, ref) {
   try {
-    for (const line of readFileSync12(join17(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
+    for (const line of readFileSync13(join18(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
       const [sha2, name2] = line.split(/\s+/);
       if (name2 === ref && sha2) return sha2;
     }
@@ -51167,7 +51335,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
   const settle = () => {
     if (timer) clearTimeout(timer);
     timer = setTimeout(() => {
-      if (existsSync13(join17(gitDir, "index.lock"))) {
+      if (existsSync14(join18(gitDir, "index.lock"))) {
         settle();
         return;
       }
@@ -51178,7 +51346,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
     }, debounceMs);
   };
   for (const sub of ["HEAD", "logs/HEAD", "MERGE_HEAD", "ORIG_HEAD"]) {
-    const p = join17(gitDir, sub);
+    const p = join18(gitDir, sub);
     try {
       watchers.push(fsWatch(p, settle));
     } catch {
@@ -51403,21 +51571,21 @@ var TelemetryRecorder = class {
 
 // src/skills.ts
 import {
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   mkdirSync as mkdirSync6,
-  readFileSync as readFileSync13,
-  readdirSync as readdirSync6,
+  readFileSync as readFileSync14,
+  readdirSync as readdirSync7,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync12
 } from "node:fs";
-import { basename as basename4, join as join18 } from "node:path";
+import { basename as basename4, join as join19 } from "node:path";
 function skillFileName(id) {
   return `${id.replace(/[^A-Za-z0-9_.-]/g, "_")}.md`;
 }
 function readSkillManifest(manifestPath) {
-  if (!existsSync14(manifestPath)) return [];
+  if (!existsSync15(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync13(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync14(manifestPath, "utf8"));
     return (parsed.skills ?? []).map((s) => ({
       title: s.title ?? "",
       layer: s.layer ?? "technique",
@@ -51433,7 +51601,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
   const staleDaemon = res.staleDaemon && res.latestDaemonVersion ? { latest: res.latestDaemonVersion } : void 0;
   mkdirSync6(paths.skillsDir, { recursive: true });
   if (res.skills.length === 0 && pins.length === 0) {
-    const existing = readdirSync6(paths.skillsDir).filter((f) => f.endsWith(".md"));
+    const existing = readdirSync7(paths.skillsDir).filter((f) => f.endsWith(".md"));
     if (existing.length > 0) return { written: 0, pruned: 0, ...staleDaemon ? { staleDaemon } : {} };
   }
   const rows = [];
@@ -51441,7 +51609,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
   for (const s of res.skills) {
     const fileName = skillFileName(s.id);
     keep.add(fileName);
-    writeFileSync11(join18(paths.skillsDir, fileName), s.markdown, "utf8");
+    writeFileSync12(join19(paths.skillsDir, fileName), s.markdown, "utf8");
     rows.push({
       id: s.id,
       title: s.title,
@@ -51454,7 +51622,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
     const fileName = skillFileName(p.id);
     if (keep.has(fileName)) continue;
     keep.add(fileName);
-    writeFileSync11(join18(paths.skillsDir, fileName), p.markdown, "utf8");
+    writeFileSync12(join19(paths.skillsDir, fileName), p.markdown, "utf8");
     rows.push({
       id: p.id,
       title: p.title,
@@ -51464,17 +51632,17 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
     });
   }
   let pruned = 0;
-  for (const f of readdirSync6(paths.skillsDir)) {
+  for (const f of readdirSync7(paths.skillsDir)) {
     if (!f.endsWith(".md")) continue;
     if (keep.has(basename4(f))) continue;
     try {
-      unlinkSync2(join18(paths.skillsDir, f));
+      unlinkSync2(join19(paths.skillsDir, f));
       pruned++;
     } catch {
     }
   }
   rows.sort((a, b) => a.id.localeCompare(b.id));
-  writeFileSync11(
+  writeFileSync12(
     paths.skillsManifest,
     JSON.stringify({ generatedAt: Date.now(), skills: rows }, null, 2),
     "utf8"
@@ -51486,22 +51654,22 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
 init_src2();
 import {
   cpSync,
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   lstatSync,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync14,
-  readdirSync as readdirSync7,
+  readFileSync as readFileSync15,
+  readdirSync as readdirSync8,
   rmSync as rmSync2,
   symlinkSync,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync13
 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 var SKILL_NS = "errata-";
 var HARNESS_SKILL_DIRS = [
-  { configDir: ".claude", skillsDir: join19(".claude", "skills") },
+  { configDir: ".claude", skillsDir: join20(".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: join19(".cursor", "skills") }
+  { configDir: ".cursor", skillsDir: join20(".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";
@@ -51546,12 +51714,12 @@ function skillCiteHandle(s) {
   return priorHandle({ id: s.id, description: s.title });
 }
 function reconcileNamespaced(dir, keep) {
-  if (!existsSync15(dir)) return 0;
+  if (!existsSync16(dir)) return 0;
   let pruned = 0;
-  for (const name2 of readdirSync7(dir)) {
+  for (const name2 of readdirSync8(dir)) {
     if (!name2.startsWith(SKILL_NS) || keep.has(name2)) continue;
     try {
-      rmSync2(join19(dir, name2), { recursive: true, force: true });
+      rmSync2(join20(dir, name2), { recursive: true, force: true });
       pruned++;
     } catch {
     }
@@ -51560,7 +51728,7 @@ function reconcileNamespaced(dir, keep) {
 }
 function linkOrCopy(linkPath, target) {
   try {
-    if (existsSync15(linkPath) || safeLstat(linkPath)) rmSync2(linkPath, { recursive: true, force: true });
+    if (existsSync16(linkPath) || safeLstat(linkPath)) rmSync2(linkPath, { recursive: true, force: true });
   } catch {
   }
   try {
@@ -51581,7 +51749,7 @@ function safeLstat(p) {
   }
 }
 function emitAndProjectSkills(root, skills) {
-  const agentsSkillsDir = join19(root, ".agents", "skills");
+  const agentsSkillsDir = join20(root, ".agents", "skills");
   mkdirSync7(agentsSkillsDir, { recursive: true });
   const slugs = [];
   const keep = /* @__PURE__ */ new Set();
@@ -51589,7 +51757,7 @@ function emitAndProjectSkills(root, skills) {
   for (const s of skills) {
     let body2;
     try {
-      body2 = readFileSync14(s.bodyPath, "utf8");
+      body2 = readFileSync15(s.bodyPath, "utf8");
     } catch {
       continue;
     }
@@ -51598,9 +51766,9 @@ function emitAndProjectSkills(root, skills) {
     keep.add(slug2);
     slugs.push(slug2);
     const description = deriveDescription(s.title, s.layer, body2);
-    mkdirSync7(join19(agentsSkillsDir, slug2), { recursive: true });
-    writeFileSync12(
-      join19(agentsSkillsDir, slug2, "SKILL.md"),
+    mkdirSync7(join20(agentsSkillsDir, slug2), { recursive: true });
+    writeFileSync13(
+      join20(agentsSkillsDir, slug2, "SKILL.md"),
       renderSkillMd(slug2, description, body2, skillCiteHandle(s)),
       "utf8"
     );
@@ -51609,11 +51777,11 @@ function emitAndProjectSkills(root, skills) {
   reconcileNamespaced(agentsSkillsDir, keep);
   let projected = 0;
   for (const h of HARNESS_SKILL_DIRS) {
-    if (!existsSync15(join19(root, h.configDir))) continue;
-    const dir = join19(root, h.skillsDir);
+    if (!existsSync16(join20(root, h.configDir))) continue;
+    const dir = join20(root, h.skillsDir);
     mkdirSync7(dir, { recursive: true });
     for (const slug2 of slugs) {
-      linkOrCopy(join19(dir, slug2), join19(agentsSkillsDir, slug2));
+      linkOrCopy(join20(dir, slug2), join20(agentsSkillsDir, slug2));
       projected++;
     }
     reconcileNamespaced(dir, keep);
@@ -51622,15 +51790,15 @@ function emitAndProjectSkills(root, skills) {
   return { slugs, emitted, projected };
 }
 function emitInputsFromManifest(erretaDir, manifestPath) {
-  if (!existsSync15(manifestPath)) return [];
+  if (!existsSync16(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync14(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync15(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: join19(erretaDir, s.file)
+      bodyPath: join20(erretaDir, s.file)
     }));
   } catch {
     return [];
@@ -51644,17 +51812,17 @@ var GITIGNORE_LINES = [
   ".cursor/skills/errata-*/"
 ];
 function ensureSkillGitignore(root) {
-  const path2 = join19(root, ".gitignore");
+  const path2 = join20(root, ".gitignore");
   let current = "";
   try {
-    current = existsSync15(path2) ? readFileSync14(path2, "utf8") : "";
+    current = existsSync16(path2) ? readFileSync15(path2, "utf8") : "";
   } catch {
     return;
   }
   if (current.includes(GITIGNORE_MARK)) return;
   const prefix = current.length > 0 && !current.endsWith("\n") ? "\n" : "";
   try {
-    writeFileSync12(path2, `${current}${prefix}
+    writeFileSync13(path2, `${current}${prefix}
 ${GITIGNORE_LINES.join("\n")}
 `, "utf8");
   } catch {
@@ -51818,20 +51986,20 @@ var CausalBuffer = class {
 // src/profile.ts
 init_src2();
 init_paths();
-import { existsSync as existsSync17, readFileSync as readFileSync16, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync17, writeFileSync as writeFileSync14 } from "node:fs";
 import { createHash as createHash12 } from "node:crypto";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 
 // src/git-remote.ts
 init_src();
-import { existsSync as existsSync16, readFileSync as readFileSync15, statSync as statSync4 } from "node:fs";
-import { isAbsolute as isAbsolute3, join as join20, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync16, statSync as statSync4 } from "node:fs";
+import { isAbsolute as isAbsolute3, join as join21, resolve as resolve5 } from "node:path";
 function resolveGitDir(root) {
-  const dotGit = join20(root, ".git");
+  const dotGit = join21(root, ".git");
   try {
     const st = statSync4(dotGit);
     if (st.isDirectory()) return dotGit;
-    const m = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync15(dotGit, "utf8"));
+    const m = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync16(dotGit, "utf8"));
     if (!m) return null;
     const dir = m[1];
     return isAbsolute3(dir) ? dir : resolve5(root, dir);
@@ -51840,22 +52008,22 @@ function resolveGitDir(root) {
   }
 }
 function gitConfigPath(gitDir) {
-  const commondirFile = join20(gitDir, "commondir");
-  if (existsSync16(commondirFile)) {
-    const common = readFileSync15(commondirFile, "utf8").trim();
+  const commondirFile = join21(gitDir, "commondir");
+  if (existsSync17(commondirFile)) {
+    const common = readFileSync16(commondirFile, "utf8").trim();
     const commonDir = isAbsolute3(common) ? common : resolve5(gitDir, common);
-    return join20(commonDir, "config");
+    return join21(commonDir, "config");
   }
-  return join20(gitDir, "config");
+  return join21(gitDir, "config");
 }
 function readRemotes(root) {
   const gitDir = resolveGitDir(root);
   if (!gitDir) return [];
   const cfgPath = gitConfigPath(gitDir);
-  if (!existsSync16(cfgPath)) return [];
+  if (!existsSync17(cfgPath)) return [];
   let txt;
   try {
-    txt = readFileSync15(cfgPath, "utf8");
+    txt = readFileSync16(cfgPath, "utf8");
   } catch {
     return [];
   }
@@ -51887,13 +52055,13 @@ function refreshRepoLocator(root, profile) {
 }
 function loadProfile(root) {
   const p = workspacePaths(root);
-  if (!existsSync17(p.workspaceJson)) return null;
-  return JSON.parse(readFileSync16(p.workspaceJson, "utf8"));
+  if (!existsSync18(p.workspaceJson)) return null;
+  return JSON.parse(readFileSync17(p.workspaceJson, "utf8"));
 }
 function saveProfile(root, profile) {
   const p = workspacePaths(root);
   ensureDir(p.configDir);
-  writeFileSync13(p.workspaceJson, JSON.stringify(profile, null, 2), "utf8");
+  writeFileSync14(p.workspaceJson, JSON.stringify(profile, null, 2), "utf8");
 }
 function autodetectProfile(root) {
   const id = workspaceId(root);
@@ -51901,10 +52069,10 @@ function autodetectProfile(root) {
   const p = emptyProfile(id, name2);
   const locator = detectRepoLocator(root);
   if (locator) p.repoLocator = locator;
-  const pkgPath = join21(root, "package.json");
-  if (existsSync17(pkgPath)) {
+  const pkgPath = join22(root, "package.json");
+  if (existsSync18(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync16(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync17(pkgPath, "utf8"));
       p.languages.push("typescript", "javascript");
       const nodeVer = pkg.engines?.node ?? "node";
       p.stack.push(`node@${nodeVer}`);
@@ -51925,10 +52093,10 @@ function autodetectProfile(root) {
     } catch {
     }
   }
-  const pyproject = join21(root, "pyproject.toml");
-  if (existsSync17(pyproject)) {
+  const pyproject = join22(root, "pyproject.toml");
+  if (existsSync18(pyproject)) {
     try {
-      const txt = readFileSync16(pyproject, "utf8");
+      const txt = readFileSync17(pyproject, "utf8");
       const py = /python\s*=\s*"([^"]+)"/.exec(txt)?.[1];
       p.languages.push("python");
       p.stack.push(`python@${py ?? "3"}`);
@@ -51939,16 +52107,16 @@ function autodetectProfile(root) {
     } catch {
     }
   }
-  const reqs = join21(root, "requirements.txt");
-  if (existsSync17(reqs)) {
+  const reqs = join22(root, "requirements.txt");
+  if (existsSync18(reqs)) {
     if (!p.languages.includes("python")) p.languages.push("python");
     if (!p.stack.includes("python@3")) p.stack.push("python@3");
   }
-  if (existsSync17(join21(root, "go.mod"))) {
+  if (existsSync18(join22(root, "go.mod"))) {
     p.languages.push("go");
     p.stack.push("go");
   }
-  if (existsSync17(join21(root, "Cargo.toml"))) {
+  if (existsSync18(join22(root, "Cargo.toml"))) {
     p.languages.push("rust");
     p.stack.push("rust");
   }
@@ -52106,7 +52274,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.196" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.204" : "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;
@@ -52116,7 +52284,7 @@ var TURN_REPLAY_LOOKBACK_MS = 7 * 24 * 60 * 6e4;
 function appendIdentityAudit(path2, record2, line) {
   if (!record2.accepted && record2.score <= 0) return;
   try {
-    if (existsSync18(path2) && statSync5(path2).size >= IDENTITY_AUDIT_MAX_BYTES) {
+    if (existsSync19(path2) && statSync5(path2).size >= IDENTITY_AUDIT_MAX_BYTES) {
       renameSync2(path2, `${path2}.1`);
     }
     appendFileSync2(path2, line);
@@ -52126,14 +52294,14 @@ function appendIdentityAudit(path2, record2, line) {
 var yieldToLoop = () => new Promise((r) => setImmediate(r));
 function loadTurnCursors(path2) {
   try {
-    return new Map(Object.entries(JSON.parse(readFileSync17(path2, "utf8"))));
+    return new Map(Object.entries(JSON.parse(readFileSync18(path2, "utf8"))));
   } catch {
     return /* @__PURE__ */ new Map();
   }
 }
 function saveTurnCursors(path2, cursors) {
   try {
-    writeFileSync14(path2, JSON.stringify(Object.fromEntries(cursors)), "utf8");
+    writeFileSync15(path2, JSON.stringify(Object.fromEntries(cursors)), "utf8");
   } catch {
   }
 }
@@ -52155,7 +52323,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(join22(root, d) + sep4));
+      ignoredDirs = igOut.split("\0").filter(Boolean).map((d) => d.replace(/\/+$/, "")).filter((d) => !IGNORED_PATH.test(join23(root, d) + sep4));
     } catch {
     }
     const hasIgnoredChild = (dir) => ignoredDirs.some((ig) => ig.startsWith(dir + "/"));
@@ -52167,19 +52335,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(join22(root, f));
+        else targets.add(join23(root, f));
       }
       for (const c of children) {
-        if (IGNORED_PATH.test(join22(root, c) + sep4)) continue;
+        if (IGNORED_PATH.test(join23(root, c) + sep4)) continue;
         if (hasIgnoredChild(c)) addUnder(c);
-        else targets.add(join22(root, c));
+        else targets.add(join23(root, c));
       }
     };
     addUnder("");
     if (targets.size > 0) return [...targets];
   } catch {
   }
-  return readdirSync8(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !IGNORED_PATH.test(join22(root, String(e.name)) + sep4)).map((e) => join22(root, String(e.name)));
+  return readdirSync9(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !IGNORED_PATH.test(join23(root, String(e.name)) + sep4)).map((e) => join23(root, String(e.name)));
 }
 function createWorkspaceEngine(opts) {
   const paths = workspacePaths(opts.workspaceRoot);
@@ -52333,7 +52501,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) => join22(opts.workspaceRoot, p));
+        const abs = srcPaths.map((p) => join23(opts.workspaceRoot, p));
         try {
           const r = await runReindexPass(
             `git-reindex:${profile.name} (${abs.length} files)`,
@@ -52369,8 +52537,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 = join22(opts.workspaceRoot, ".git");
-    if (existsSync18(gitDir)) {
+    const gitDir = join23(opts.workspaceRoot, ".git");
+    if (existsSync19(gitDir)) {
       stopGit = startGitSensor(gitDir, (ev) => {
         void handleGitEvent(ev).catch((err2) => {
           console.warn("[errata] git event handler failed:", err2);
@@ -52440,10 +52608,10 @@ function createWorkspaceEngine(opts) {
     });
     doneRender?.();
     writeContextFile(opts.workspaceRoot, body2);
-    const target = join22(opts.workspaceRoot, "AGENTS.md");
+    const target = join23(opts.workspaceRoot, "AGENTS.md");
     writeManagedBlock(target, { body: AGENTS_POINTER_BODY, stable: true, force: true });
     if (elicit) {
-      writePrimingHandles(join22(paths.configDir, "priming-handles.json"), [
+      writePrimingHandles(join23(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
@@ -52534,6 +52702,21 @@ function createWorkspaceEngine(opts) {
     } catch (err2) {
       console.warn("[errata] anchor backfill failed:", err2);
     }
+    try {
+      const c = backfillConstraintKind(store, {
+        root: opts.workspaceRoot,
+        configDir: paths.configDir,
+        now: Date.now()
+      });
+      if (!c.skipped && (c.stamped > 0 || c.detached > 0)) {
+        console.log(
+          `[errata] constraint backfill: ${c.stamped} design tension(s) marked` + (c.detached > 0 ? `; ${c.detached} fabricated resolution(s) detached, ${c.reopened} reopened` : "") + (c.witnessed > 0 ? `; ${c.witnessed} cited discharge(s) kept` : "") + (c.cloudTwins.length > 0 ? ` \u2014 ${c.cloudTwins.length} already contributed; run scripts/repair-cloud-constraints.ts to repair the cloud twins` : "")
+        );
+        refreshContextNow();
+      }
+    } catch (err2) {
+      console.warn("[errata] constraint backfill failed:", err2);
+    }
     const report = runNightlyPipeline(store);
     try {
       const m = mergeDuplicateProblems(store, { ts: Date.now() });
@@ -52633,7 +52816,7 @@ function createWorkspaceEngine(opts) {
       resultSummary: { exitCode: e.exitCode ?? 1, errorTokens: e.errorTokens }
     });
   };
-  const turnCursorPath = join22(paths.configDir, "turn-cursors.json");
+  const turnCursorPath = join23(paths.configDir, "turn-cursors.json");
   const lastTurnUuid = loadTurnCursors(turnCursorPath);
   const sessionLastProblem = /* @__PURE__ */ new Map();
   const sessionThreads = /* @__PURE__ */ new Map();
@@ -52656,7 +52839,7 @@ function createWorkspaceEngine(opts) {
     const t = Date.now();
     let processedTurns = 0;
     const elicit = isEdgeElicitationEnabled();
-    const handleMap = elicit ? readPrimingHandles(join22(paths.configDir, "priming-handles.json")) : {};
+    const handleMap = elicit ? readPrimingHandles(join23(paths.configDir, "priming-handles.json")) : {};
     const wsRoot = (opts.workspaceRoot ?? "").replace(/\\/g, "/");
     const toRel = (abs) => {
       const p = abs.replace(/\\/g, "/");
@@ -53191,7 +53374,7 @@ function createWorkspaceEngine(opts) {
     try {
       const inputs = emitInputsFromManifest(paths.configDir, paths.skillsManifest);
       emitAndProjectSkills(opts.workspaceRoot, inputs);
-      writePrimingHandles(join22(paths.configDir, "priming-handles.json"), skillHandleNodes(inputs));
+      writePrimingHandles(join23(paths.configDir, "priming-handles.json"), skillHandleNodes(inputs));
     } catch (err2) {
       console.warn("[skills] agent-skills projection failed (non-fatal):", err2 instanceof Error ? err2.message : err2);
     }
@@ -53378,7 +53561,7 @@ function createWorkspaceEngine(opts) {
         console.log(
           "[errata] sync skipped \u2014 cloud sync consent is off (enable with `errata consent sync on`)"
         );
-        const pending = existsSync18(paths.outbox) ? readdirSync8(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
+        const pending = existsSync19(paths.outbox) ? readdirSync9(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
         return { uploaded: 0, failed: 0, remaining: pending };
       }
       try {
@@ -53465,7 +53648,7 @@ async function startDaemon(opts) {
     reviewUrl: () => webUiUrl + "/review"
   });
   const writeLockFile = (url2) => {
-    writeFileSync15(
+    writeFileSync16(
       engine.paths.daemonLock,
       JSON.stringify({ pid: process.pid, webUiUrl: url2, startedAt: Date.now() }),
       "utf8"
@@ -53508,7 +53691,7 @@ async function startDaemon(opts) {
       );
       await engine.stop();
       try {
-        if (existsSync19(engine.paths.daemonLock)) {
+        if (existsSync20(engine.paths.daemonLock)) {
         }
       } catch {
       }
@@ -53525,16 +53708,16 @@ async function listenServer(fetchFn, port) {
 
 // src/registry.ts
 init_paths();
-import { existsSync as existsSync20, readFileSync as readFileSync18, writeFileSync as writeFileSync16 } from "node:fs";
-import { join as join23 } from "node:path";
+import { existsSync as existsSync21, readFileSync as readFileSync19, writeFileSync as writeFileSync17 } from "node:fs";
+import { join as join24 } from "node:path";
 function registryPath() {
-  return process.env["ERRATA_REGISTRY_PATH"] ?? join23(globalDir(), "workspaces.json");
+  return process.env["ERRATA_REGISTRY_PATH"] ?? join24(globalDir(), "workspaces.json");
 }
 function read() {
   const p = registryPath();
-  if (!existsSync20(p)) return { version: 1, workspaces: {} };
+  if (!existsSync21(p)) return { version: 1, workspaces: {} };
   try {
-    const parsed = JSON.parse(readFileSync18(p, "utf8"));
+    const parsed = JSON.parse(readFileSync19(p, "utf8"));
     return { version: 1, workspaces: parsed.workspaces ?? {} };
   } catch {
     return { version: 1, workspaces: {} };
@@ -53542,7 +53725,7 @@ function read() {
 }
 function write(reg) {
   ensureDir(globalDir());
-  writeFileSync16(registryPath(), JSON.stringify(reg, null, 2), "utf8");
+  writeFileSync17(registryPath(), JSON.stringify(reg, null, 2), "utf8");
 }
 function registerWorkspace(profile, root, now = Date.now()) {
   const reg = read();
@@ -53559,7 +53742,7 @@ function pruneMissingWorkspaces() {
   const reg = read();
   const removed = [];
   for (const [id, entry] of Object.entries(reg.workspaces)) {
-    if (!existsSync20(entry.path)) {
+    if (!existsSync21(entry.path)) {
       removed.push(entry);
       delete reg.workspaces[id];
     }
@@ -53568,13 +53751,13 @@ function pruneMissingWorkspaces() {
   return removed;
 }
 function workspaceStatus(entry) {
-  const missing = !existsSync20(entry.path);
+  const missing = !existsSync21(entry.path);
   const lockPath = workspacePaths(entry.path).daemonLock;
   let running = false;
   let webUiUrl = null;
-  if (existsSync20(lockPath)) {
+  if (existsSync21(lockPath)) {
     try {
-      const lock = JSON.parse(readFileSync18(lockPath, "utf8"));
+      const lock = JSON.parse(readFileSync19(lockPath, "utf8"));
       if (lock.pid && lock.webUiUrl && pidAlive(lock.pid)) {
         running = true;
         webUiUrl = lock.webUiUrl;
@@ -53602,7 +53785,7 @@ function pidAlive(pid) {
 // src/multi.ts
 init_dist();
 init_src4();
-import { readFileSync as readFileSync21, unlinkSync as unlinkSync3, writeFileSync as writeFileSync17 } from "node:fs";
+import { readFileSync as readFileSync22, unlinkSync as unlinkSync3, writeFileSync as writeFileSync18 } from "node:fs";
 
 // src/principle-sync.ts
 init_src4();
@@ -53630,8 +53813,8 @@ init_reconcile();
 
 // src/lockfile-auto.ts
 init_src();
-import { existsSync as existsSync21, readFileSync as readFileSync19 } from "node:fs";
-import { join as join24 } from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync20 } from "node:fs";
+import { join as join25 } from "node:path";
 
 // src/package-index.ts
 init_src();
@@ -53777,11 +53960,11 @@ function runLockfilePass(opts) {
     { file: "package-lock.json", parse: parsePackageLockJson }
   ];
   for (const c of candidates) {
-    const p = join24(opts.root, c.file);
-    if (!existsSync21(p)) continue;
+    const p = join25(opts.root, c.file);
+    if (!existsSync22(p)) continue;
     let sbom;
     try {
-      sbom = c.parse(readFileSync19(p, "utf8"));
+      sbom = c.parse(readFileSync20(p, "utf8"));
     } catch {
       continue;
     }
@@ -54224,7 +54407,7 @@ var ConsolidateWorker = class {
 init_paths();
 
 // src/lock.ts
-import { existsSync as existsSync22, readFileSync as readFileSync20 } from "node:fs";
+import { existsSync as existsSync23, readFileSync as readFileSync21 } from "node:fs";
 function isProcessAlive(pid) {
   if (!pid || pid <= 0) return false;
   try {
@@ -54235,9 +54418,9 @@ function isProcessAlive(pid) {
   }
 }
 function readDaemonLock(lockPath) {
-  if (!existsSync22(lockPath)) return null;
+  if (!existsSync23(lockPath)) return null;
   try {
-    const lock = JSON.parse(readFileSync20(lockPath, "utf8"));
+    const lock = JSON.parse(readFileSync21(lockPath, "utf8"));
     return typeof lock.pid === "number" ? lock : null;
   } catch {
     return null;
@@ -54479,12 +54662,12 @@ async function reanchorProject(opts) {
 }
 
 // src/adopt.ts
-import { existsSync as existsSync23 } from "node:fs";
-import { dirname as dirname9, join as join25 } from "node:path";
+import { existsSync as existsSync24 } from "node:fs";
+import { dirname as dirname9, join as join26 } from "node:path";
 function findGitRoot(absPath) {
   let dir = absPath;
   for (let depth = 0; depth < 64; depth++) {
-    if (existsSync23(join25(dir, ".git"))) return dir;
+    if (existsSync24(join26(dir, ".git"))) return dir;
     const parent = dirname9(dir);
     if (parent === dir) return null;
     dir = parent;
@@ -54706,7 +54889,7 @@ async function startMultiDaemon(opts = {}) {
     void ambientLinkAll();
     app.route(`/ws/${rec.id}`, rec.webApp);
     try {
-      writeFileSync17(
+      writeFileSync18(
         rec.engine.paths.daemonLock,
         JSON.stringify({ pid: process.pid, webUiUrl: `${baseUrl}/ws/${rec.id}`, startedAt: Date.now() }),
         "utf8"
@@ -54895,7 +55078,7 @@ async function startMultiDaemon(opts = {}) {
   baseUrl = `http://127.0.0.1:${port}`;
   try {
     ensureDir(globalDir());
-    writeFileSync17(
+    writeFileSync18(
       lockPath,
       JSON.stringify({ pid: process.pid, webUiUrl: baseUrl, startedAt: Date.now() }),
       "utf8"
@@ -54904,7 +55087,7 @@ async function startMultiDaemon(opts = {}) {
   }
   for (const r of records) {
     try {
-      writeFileSync17(
+      writeFileSync18(
         r.engine.paths.daemonLock,
         JSON.stringify({ pid: process.pid, webUiUrl: `${baseUrl}/ws/${r.id}`, startedAt: Date.now() }),
         "utf8"
@@ -55372,7 +55555,7 @@ async function startMultiDaemon(opts = {}) {
     },
     async stop() {
       try {
-        const cur = readFileSync21(lockPath, "utf8");
+        const cur = readFileSync22(lockPath, "utf8");
         if (JSON.parse(cur).pid === process.pid) unlinkSync3(lockPath);
       } catch {
       }
@@ -56392,21 +56575,21 @@ async function cmdInit() {
   if (!skipHooks) {
     console.log("");
     console.log("installing harness hooks...");
-    const { existsSync: existsSync25 } = await import("node:fs");
-    const { join: join27 } = await import("node:path");
+    const { existsSync: existsSync26 } = await import("node:fs");
+    const { join: join28 } = 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 (existsSync25(join27(ROOT, ".cursor"))) {
+    if (existsSync26(join28(ROOT, ".cursor"))) {
       try {
         await installCursorMcpConfig();
       } catch (err2) {
         console.warn(`  \u26A0\uFE0F  Cursor MCP config failed: ${err2 instanceof Error ? err2.message : err2}`);
       }
     }
-    if (existsSync25(join27(ROOT, ".codex"))) {
+    if (existsSync26(join28(ROOT, ".codex"))) {
       try {
         await installCodexHooks(port);
       } catch (err2) {
@@ -56563,8 +56746,8 @@ async function cmdStatus() {
     console.log(`    stack:     ${profile.stack.join(", ") || "(none)"}`);
     console.log(`    languages: ${profile.languages.join(", ") || "(none)"}`);
   }
-  console.log(`  graph db:  ${existsSync24(paths.castalia) ? "yes" : "no"} (${paths.castalia})`);
-  console.log(`  event log: ${existsSync24(paths.eventLog) ? "yes" : "no"} (${paths.eventLog})`);
+  console.log(`  graph db:  ${existsSync25(paths.castalia) ? "yes" : "no"} (${paths.castalia})`);
+  console.log(`  event log: ${existsSync25(paths.eventLog) ? "yes" : "no"} (${paths.eventLog})`);
   const lockPath = globalDaemonLock();
   const running = isDaemonAlive(lockPath) ? readDaemonLock(lockPath) : null;
   console.log(
@@ -57194,11 +57377,11 @@ function cmdInstallationProfile(args2) {
 }
 async function cmdReview() {
   const paths = workspacePaths(ROOT);
-  if (!existsSync24(paths.reviewQueue)) {
+  if (!existsSync25(paths.reviewQueue)) {
     console.log("(review queue empty)");
     return;
   }
-  const queue = JSON.parse(readFileSync22(paths.reviewQueue, "utf8"));
+  const queue = JSON.parse(readFileSync23(paths.reviewQueue, "utf8"));
   if (queue.length === 0) {
     console.log("(review queue empty)");
     return;
@@ -57869,7 +58052,7 @@ async function gatherRepo(store, ws) {
   };
 }
 async function gatherReportData(generatedAt) {
-  const { existsSync: existsSync25 } = await import("node:fs");
+  const { existsSync: existsSync26 } = await import("node:fs");
   const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src4(), src_exports2));
   const cfg = loadConfig();
   const outbound = cfg.consent.sync ? "auto" : "off";
@@ -57877,7 +58060,7 @@ async function gatherReportData(generatedAt) {
   for (const ws of listWorkspaces()) {
     if (ws.missing) continue;
     const dbPath = workspacePaths(ws.path).castalia;
-    if (!existsSync25(dbPath)) continue;
+    if (!existsSync26(dbPath)) continue;
     let store = null;
     try {
       store = openGraphStore2({ path: dbPath });
@@ -57908,7 +58091,7 @@ async function gatherReportData(generatedAt) {
   };
 }
 async function cmdReport(args2) {
-  const { mkdirSync: mkdirSync8, writeFileSync: writeFileSync18 } = await import("node:fs");
+  const { mkdirSync: mkdirSync8, writeFileSync: writeFileSync19 } = await import("node:fs");
   const { renderReport: renderReport2 } = await Promise.resolve().then(() => (init_report_render(), report_render_exports));
   const includeFutureVerbs = args2.includes("--future-verbs");
   const now = /* @__PURE__ */ new Date();
@@ -57921,8 +58104,8 @@ async function cmdReport(args2) {
   const outDir = workspacePaths(ROOT).configDir;
   mkdirSync8(outDir, { recursive: true });
   const files = renderReport2(data, { includeFutureVerbs });
-  for (const f of files) writeFileSync18(join26(outDir, f.name), f.html, "utf8");
-  const indexPath = join26(outDir, "report.html");
+  for (const f of files) writeFileSync19(join27(outDir, f.name), f.html, "utf8");
+  const indexPath = join27(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`
@@ -58040,15 +58223,15 @@ function hookRelayCommand(port, path2) {
   return process.platform === "win32" ? `cmd //c "curl -s --connect-timeout 1 --max-time 2 -X POST -H \\"Content-Type: application/json\\" --data-binary @- ${url2} 2>NUL || echo {}"` : `curl -s --connect-timeout 1 --max-time 2 -X POST -H 'Content-Type: application/json' --data-binary @- ${url2} 2>/dev/null || echo '{}'`;
 }
 async function installClaudeHooks(port) {
-  const { mkdirSync: mkdirSync8, existsSync: existsSync25, readFileSync: readFileSync23, writeFileSync: writeFileSync18 } = await import("node:fs");
-  const { join: join27 } = await import("node:path");
-  const dir = join27(ROOT, ".claude");
-  if (!existsSync25(dir)) mkdirSync8(dir, { recursive: true });
-  const file2 = join27(dir, "settings.json");
+  const { mkdirSync: mkdirSync8, existsSync: existsSync26, readFileSync: readFileSync24, writeFileSync: writeFileSync19 } = await import("node:fs");
+  const { join: join28 } = await import("node:path");
+  const dir = join28(ROOT, ".claude");
+  if (!existsSync26(dir)) mkdirSync8(dir, { recursive: true });
+  const file2 = join28(dir, "settings.json");
   let settings = {};
-  if (existsSync25(file2)) {
+  if (existsSync26(file2)) {
     try {
-      settings = JSON.parse(readFileSync23(file2, "utf8"));
+      settings = JSON.parse(readFileSync24(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -58094,10 +58277,10 @@ async function installClaudeHooks(port) {
     dropErrata(list);
     list.push({ hooks: [{ type: "command", command: injectCmd }] });
   }
-  writeFileSync18(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  writeFileSync19(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
   console.log(`installed Claude Code hooks \u2192 ${file2}`);
   await installClaudeMcpConfig();
-  const claudeMd = join27(ROOT, "CLAUDE.md");
+  const claudeMd = join28(ROOT, "CLAUDE.md");
   const recall = writeManagedBlock(claudeMd, { body: RECALL_FIRST_BLOCK });
   if (recall.kind === "collision") {
     console.warn(
@@ -58109,15 +58292,15 @@ async function installClaudeHooks(port) {
   console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
 }
 async function installClaudeMcpConfig() {
-  const { mkdirSync: mkdirSync8, existsSync: existsSync25, readFileSync: readFileSync23, writeFileSync: writeFileSync18 } = await import("node:fs");
-  const { join: join27, dirname: dirname10 } = await import("node:path");
-  const file2 = join27(ROOT, ".mcp.json");
+  const { mkdirSync: mkdirSync8, existsSync: existsSync26, readFileSync: readFileSync24, writeFileSync: writeFileSync19 } = await import("node:fs");
+  const { join: join28, dirname: dirname10 } = await import("node:path");
+  const file2 = join28(ROOT, ".mcp.json");
   const dir = dirname10(file2);
-  if (!existsSync25(dir)) mkdirSync8(dir, { recursive: true });
+  if (!existsSync26(dir)) mkdirSync8(dir, { recursive: true });
   let cfg = {};
-  if (existsSync25(file2)) {
+  if (existsSync26(file2)) {
     try {
-      cfg = JSON.parse(readFileSync23(file2, "utf8"));
+      cfg = JSON.parse(readFileSync24(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -58125,21 +58308,21 @@ async function installClaudeMcpConfig() {
   }
   cfg.mcpServers ??= {};
   cfg.mcpServers["errata"] = errataMcpInvocation();
-  writeFileSync18(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  writeFileSync19(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   console.log(`installed Claude Code MCP server config \u2192 ${file2}`);
   console.log(`  Claude Code will spawn \`errata mcp\` on workspace open.`);
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses / show / similar`);
 }
 async function installCursorMcpConfig() {
-  const { mkdirSync: mkdirSync8, existsSync: existsSync25, readFileSync: readFileSync23, writeFileSync: writeFileSync18 } = await import("node:fs");
-  const { join: join27 } = await import("node:path");
-  const dir = join27(ROOT, ".cursor");
-  if (!existsSync25(dir)) mkdirSync8(dir, { recursive: true });
-  const file2 = join27(dir, "mcp.json");
+  const { mkdirSync: mkdirSync8, existsSync: existsSync26, readFileSync: readFileSync24, writeFileSync: writeFileSync19 } = await import("node:fs");
+  const { join: join28 } = await import("node:path");
+  const dir = join28(ROOT, ".cursor");
+  if (!existsSync26(dir)) mkdirSync8(dir, { recursive: true });
+  const file2 = join28(dir, "mcp.json");
   let cfg = {};
-  if (existsSync25(file2)) {
+  if (existsSync26(file2)) {
     try {
-      cfg = JSON.parse(readFileSync23(file2, "utf8"));
+      cfg = JSON.parse(readFileSync24(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -58147,7 +58330,7 @@ async function installCursorMcpConfig() {
   }
   cfg.mcpServers ??= {};
   cfg.mcpServers["errata"] = errataMcpInvocation();
-  writeFileSync18(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  writeFileSync19(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   console.log(`installed Cursor MCP server config \u2192 ${file2}`);
   console.log(`  Cursor will spawn \`errata mcp\` on workspace open.`);
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses`);
@@ -58155,16 +58338,16 @@ async function installCursorMcpConfig() {
   console.log(`  \u26A0\uFE0F  reload Cursor (Cmd/Ctrl-Shift-P \u2192 "Reload Window") to pick it up.`);
 }
 async function installCodexHooks(port) {
-  const { mkdirSync: mkdirSync8, existsSync: existsSync25, readFileSync: readFileSync23, writeFileSync: writeFileSync18 } = await import("node:fs");
-  const { join: join27 } = await import("node:path");
-  const dir = join27(ROOT, ".codex");
-  if (!existsSync25(dir)) mkdirSync8(dir, { recursive: true });
-  const file2 = join27(dir, "config.toml");
+  const { mkdirSync: mkdirSync8, existsSync: existsSync26, readFileSync: readFileSync24, writeFileSync: writeFileSync19 } = await import("node:fs");
+  const { join: join28 } = await import("node:path");
+  const dir = join28(ROOT, ".codex");
+  if (!existsSync26(dir)) mkdirSync8(dir, { recursive: true });
+  const file2 = join28(dir, "config.toml");
   const BEGIN = `# >>> errata hooks (errata-managed)`;
   const END = `# <<< errata hooks`;
   let existing = "";
-  if (existsSync25(file2)) {
-    existing = readFileSync23(file2, "utf8");
+  if (existsSync26(file2)) {
+    existing = readFileSync24(file2, "utf8");
     const beginIdx = existing.indexOf(BEGIN);
     const endIdx = existing.indexOf(END);
     if (beginIdx >= 0 && endIdx > beginIdx) {
@@ -58193,7 +58376,7 @@ ${END}
   const final = existing.length > 0 && !existing.endsWith("\n") ? `${existing}
 
 ${block}` : existing + (existing.endsWith("\n\n") ? "" : "\n") + block;
-  writeFileSync18(file2, final, "utf8");
+  writeFileSync19(file2, final, "utf8");
   console.log(`installed Codex hooks \u2192 ${file2}`);
   console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
   console.log("");
@@ -58483,7 +58666,7 @@ async function cmdDash(args2) {
       await yieldToLoop2();
       try {
         const items = selectDurableMemory(handle2.sharedStore, r.engine.profile);
-        const res = bleedRules(join26(r.root, ".claude", "rules"), items);
+        const res = bleedRules(join27(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` : "")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.2-dev.196",
+  "version": "2.0.2-dev.204",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {

package/pass-worker.mjs

@@ -26106,10 +26106,13 @@ function buildSnapshot(opts) {
     episodeId,
     problems: problems2
   }));
-  const needsRevisit = listNeedsRevisit(
-    opts.store,
-    (opts.now ?? /* @__PURE__ */ new Date()).getTime()
-  ).slice(0, 10);
+  const revisitSeen = /* @__PURE__ */ new Set();
+  const needsRevisit = listNeedsRevisit(opts.store, (opts.now ?? /* @__PURE__ */ new Date()).getTime()).filter((r) => {
+    const key = `${r.label}:${r.description.trim().toLowerCase()}`;
+    if (revisitSeen.has(key)) return false;
+    revisitSeen.add(key);
+    return true;
+  }).slice(0, 5);
   const norm = (x) => x.toLowerCase().replace(/[^a-z0-9]+/g, "");
   const pkgBase = (x) => {
     const at = x.lastIndexOf("@");