@inerrata-corporation/errata 2.0.22-dev.4173 → 2.0.22-dev.4186

package/errata.mjs

@@ -18137,20 +18137,20 @@ function openDatabase(path3, opts) {
     } catch {
     }
   }
-  const wrapStmt = (stmt) => ({
+  const wrapStmt = (stmt2) => ({
     run: (...params) => {
-      const r = stmt.run(...coerceParams(params));
+      const r = stmt2.run(...coerceParams(params));
       return {
         changes: Number(r.changes),
         lastInsertRowid: Number(r.lastInsertRowid)
       };
     },
     get: (...params) => {
-      const r = stmt.get(...coerceParams(params));
+      const r = stmt2.get(...coerceParams(params));
       return r;
     },
     all: (...params) => {
-      const r = stmt.all(...coerceParams(params));
+      const r = stmt2.all(...coerceParams(params));
       return r;
     }
   });
@@ -19134,6 +19134,175 @@ var init_text_index = __esm({
   }
 });
 
+// ../../packages/local-graph/src/lineage-integrity.ts
+function stmt(db, sql) {
+  let byDb = statements.get(db);
+  if (!byDb) statements.set(db, byDb = /* @__PURE__ */ new Map());
+  let s = byDb.get(sql);
+  if (!s) byDb.set(sql, s = db.prepare(sql));
+  return s;
+}
+function countStrandedEdges(db) {
+  const rows = db.prepare(`SELECT e.type AS type, count(*) AS n FROM edges e WHERE ${STRANDED_EDGE_PREDICATE} GROUP BY e.type ORDER BY n DESC`).all();
+  const byType = {};
+  let total = 0;
+  for (const r of rows) {
+    byType[r.type] = Number(r.n);
+    total += Number(r.n);
+  }
+  return { total, byType };
+}
+function countLiveHeadConflicts(db) {
+  const row = db.prepare(
+    `SELECT count(*) AS n FROM (
+         SELECT COALESCE(logical_id, id) AS lid FROM nodes
+         WHERE valid_to IS NULL AND ${NOT_HISTORICAL_ROW}
+         GROUP BY lid HAVING count(*) > 1)`
+  ).get();
+  return Number(row?.n ?? 0);
+}
+function closeIncidentEdges(db, id, t) {
+  let closed = 0;
+  for (const side of ["from_id", "to_id"]) {
+    const r = stmt(db, `UPDATE edges SET valid_to = MAX(valid_from, ?) WHERE ${side} = ? AND valid_to IS NULL AND ${NOT_HISTORY}`).run(t, id);
+    closed += Number(r.changes);
+  }
+  return closed;
+}
+function reopenCascadeClosedEdges(db, id, closedAt) {
+  let reopened = 0;
+  for (const [side, other] of [["from_id", "to_id"], ["to_id", "from_id"]]) {
+    const r = stmt(
+      db,
+      `UPDATE edges SET valid_to = NULL
+       WHERE ${side} = ? AND valid_to = ? AND ${NOT_HISTORY}
+         AND EXISTS (SELECT 1 FROM nodes o WHERE o.id = edges.${other} AND o.valid_to IS NULL)`
+    ).run(id, closedAt);
+    reopened += Number(r.changes);
+  }
+  return reopened;
+}
+function collapseLiveHeads(db, logicalIds, t) {
+  const headsOf = db.prepare(
+    `SELECT id, version, valid_from FROM (
+       SELECT id, version, valid_from, attrs_json FROM nodes WHERE logical_id = ?1 AND valid_to IS NULL
+       UNION
+       SELECT id, version, valid_from, attrs_json FROM nodes WHERE id = ?1 AND logical_id IS NULL AND valid_to IS NULL
+     ) WHERE ${NOT_HISTORICAL_ROW}`
+  );
+  const continuesInto = db.prepare(
+    `SELECT to_id FROM edges WHERE from_id = ? AND type = 'CONTINUES' AND valid_to IS NULL`
+  );
+  const rekeyHead = db.prepare(`UPDATE nodes SET logical_id = ?1 WHERE id = ?1`);
+  const rekeyCopies = db.prepare(
+    `UPDATE nodes SET logical_id = ?1 WHERE logical_id = ?2 AND substr(id, 1, length(?1) + 2) = ?1 || '@v'`
+  );
+  const lineageMembers = db.prepare(
+    `SELECT id FROM nodes WHERE logical_id = ?1 UNION SELECT id FROM nodes WHERE id = ?1`
+  );
+  const closeContinues = db.prepare(
+    `UPDATE edges SET valid_to = MAX(valid_from, ?) WHERE from_id = ? AND to_id = ? AND type = 'CONTINUES' AND valid_to IS NULL`
+  );
+  let split = 0;
+  const queue = [...new Set(logicalIds)];
+  for (let i2 = 0; i2 < queue.length; i2++) {
+    const lid = queue[i2];
+    const heads = headsOf.all(lid);
+    if (heads.length < 2) continue;
+    const members = new Set(lineageMembers.all(lid).map((r) => r.id));
+    const splitOff = (h) => {
+      for (const { to_id } of continuesInto.all(h.id)) {
+        if (members.has(to_id)) closeContinues.run(t, h.id, to_id);
+      }
+      rekeyHead.run(h.id);
+      rekeyCopies.run(h.id, lid);
+      queue.push(h.id);
+      split++;
+    };
+    const kept = new Set(heads.map((h) => h.id));
+    for (const h of heads) {
+      if (h.id === lid) continue;
+      const refuted = continuesInto.all(h.id).some(
+        (e) => e.to_id !== h.id && kept.has(e.to_id)
+      );
+      if (refuted && kept.size > 1) {
+        splitOff(h);
+        kept.delete(h.id);
+      }
+    }
+    let remaining = heads.filter((h) => kept.has(h.id));
+    if (remaining.length < 2) continue;
+    remaining = [...remaining].sort(
+      (a, b) => Number(b.id === lid) - Number(a.id === lid) || Number(b.version) - Number(a.version) || Number(b.valid_from) - Number(a.valid_from) || (a.id < b.id ? -1 : 1)
+    );
+    for (const h of remaining.slice(1)) splitOff(h);
+  }
+  return split;
+}
+function repairLineageIntegrity(db, now) {
+  const historicalRowsClosed = Number(
+    db.prepare(
+      `UPDATE nodes SET valid_to = MAX(valid_from, COALESCE(
+           (SELECT s.valid_from FROM edges s WHERE s.id = 'edge_superseded_' || nodes.id), ?))
+         WHERE valid_to IS NULL AND json_type(attrs_json, '$.historical') = 'true'`
+    ).run(now).changes
+  );
+  const conflicted = db.prepare(
+    `SELECT COALESCE(logical_id, id) AS lid FROM nodes
+         WHERE valid_to IS NULL AND ${NOT_HISTORICAL_ROW}
+         GROUP BY lid HAVING count(*) > 1`
+  ).all().map((r) => r.lid);
+  const headsSplit = collapseLiveHeads(db, conflicted, now);
+  const strandedEdgesClosed = Number(
+    db.prepare(
+      `UPDATE edges SET valid_to = MAX(valid_from, COALESCE(
+           (SELECT min(v) FROM (
+              SELECT f.valid_to AS v FROM nodes f WHERE f.id = edges.from_id AND NOT ${PRESENT("f")}
+              UNION ALL
+              SELECT t.valid_to FROM nodes t WHERE t.id = edges.to_id AND NOT ${PRESENT("t")})), ?))
+         WHERE id IN (SELECT e.id FROM edges e WHERE ${STRANDED_EDGE_PREDICATE})`
+    ).run(now).changes
+  );
+  return { historicalRowsClosed, headsSplit, strandedEdgesClosed };
+}
+function installLineageIntegrityRepair(db, now = Date.now()) {
+  if (db.prepare("SELECT value FROM store_meta WHERE key = ?").get(LINEAGE_INTEGRITY_KEY)) return null;
+  return db.transaction(() => {
+    const report = repairLineageIntegrity(db, now);
+    db.prepare("INSERT OR REPLACE INTO store_meta (key, value) VALUES (?, ?)").run(
+      LINEAGE_INTEGRITY_KEY,
+      JSON.stringify({ at: now, ...report })
+    );
+    return report;
+  });
+}
+var statements, HISTORY_EDGE_TYPES, LINEAGE_INTEGRITY_KEY, HISTORY_SQL, NOT_HISTORY, NOT_HISTORICAL_ROW, RETAINS_EDGES, PRESENT, STRANDED_EDGE_PREDICATE;
+var init_lineage_integrity = __esm({
+  "../../packages/local-graph/src/lineage-integrity.ts"() {
+    "use strict";
+    statements = /* @__PURE__ */ new WeakMap();
+    HISTORY_EDGE_TYPES = [
+      "SUPERSEDED_BY",
+      "CONTINUES",
+      "FORKED_FROM",
+      "REGRESSION_OF",
+      "SPLIT_INTO",
+      "REVEALED_BY"
+    ];
+    LINEAGE_INTEGRITY_KEY = "lineage-integrity-v1";
+    HISTORY_SQL = HISTORY_EDGE_TYPES.map((t) => `'${t}'`).join(",");
+    NOT_HISTORY = `type NOT IN (${HISTORY_SQL})`;
+    NOT_HISTORICAL_ROW = `json_type(attrs_json, '$.historical') IS NOT 'true'`;
+    RETAINS_EDGES = (n) => `(${n}.label = 'Problem'
+  AND json_type(${n}.attrs_json, '$.resolvedAt') IS NOT NULL
+  AND COALESCE(json_extract(${n}.attrs_json, '$.resolvedAs'), '') NOT IN ('duplicate', 'false_positive'))`;
+    PRESENT = (n) => `(${n}.valid_to IS NULL OR ${RETAINS_EDGES(n)})`;
+    STRANDED_EDGE_PREDICATE = `e.valid_to IS NULL AND e.${NOT_HISTORY}
+  AND (NOT EXISTS (SELECT 1 FROM nodes f WHERE f.id = e.from_id AND ${PRESENT("f")})
+    OR NOT EXISTS (SELECT 1 FROM nodes t WHERE t.id = e.to_id AND ${PRESENT("t")}))`;
+  }
+});
+
 // ../../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, 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 init_constants = __esm({
@@ -20219,7 +20388,7 @@ function graphStoreNeedsPreparation(path3) {
     for (const match2 of (SCHEMA_SQL + TEMPORAL_INDEX_SQL).matchAll(/CREATE INDEX IF NOT EXISTS (\w+)/g)) {
       if (!indexes.has(match2[1])) return true;
     }
-    return [SESSION_REPAIR_KEY, HISTORY_CACHE_FLOOR_KEY, EDIT_PLACEHOLDER_FLOOR_KEY, CLOUD_ATTR_COMPACTION_KEY, HISTORY_ATTR_SLIM_KEY, TEXT_INDEX_KEY].some((key) => !db.prepare("SELECT value FROM store_meta WHERE key = ?").get(key));
+    return [SESSION_REPAIR_KEY, HISTORY_CACHE_FLOOR_KEY, EDIT_PLACEHOLDER_FLOOR_KEY, CLOUD_ATTR_COMPACTION_KEY, HISTORY_ATTR_SLIM_KEY, TEXT_INDEX_KEY, LINEAGE_INTEGRITY_KEY].some((key) => !db.prepare("SELECT value FROM store_meta WHERE key = ?").get(key));
   } catch {
     return true;
   } finally {
@@ -20298,6 +20467,7 @@ var init_store = __esm({
     init_cloud_attr_compaction();
     init_history_attr_slim();
     init_text_index();
+    init_lineage_integrity();
     init_src3();
     init_node_select();
     PAGE_RANK_SCALE_KEY = "pageRankScale.p95.v1";
@@ -20523,6 +20693,7 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
             this.db.prepare("INSERT OR REPLACE INTO store_meta (key, value) VALUES (?, 'done')").run(SESSION_REPAIR_KEY);
           });
         }
+        installLineageIntegrityRepair(this.db);
         this.stmts = {
           insertNode: this.db.prepare(`
         INSERT INTO nodes (
@@ -20733,6 +20904,12 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
         AND (t.id IS NULL OR t.valid_to IS NOT NULL)
     `).all();
       }
+      strandedEdges() {
+        return countStrandedEdges(this.db);
+      }
+      liveHeadConflicts() {
+        return countLiveHeadConflicts(this.db);
+      }
       fileIndexStates(ids) {
         if (ids.length === 0) return [];
         if (ids.length > 500) throw new RangeError("fileIndexStates accepts at most 500 ids per read");
@@ -20901,15 +21078,15 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
       findNodeFieldsByLabel(label, attrKeys) {
         for (const k of attrKeys) if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(k)) throw new Error(`findNodeFieldsByLabel: bad attr key ${k}`);
         const cacheKey2 = attrKeys.join(",");
-        let stmt = this.fieldStmts.get(cacheKey2);
-        if (!stmt) {
+        let stmt2 = this.fieldStmts.get(cacheKey2);
+        if (!stmt2) {
           const cols = attrKeys.map((k, i2) => `, ${attrValueSql(`'$.${k}'`)} AS a${i2}, json_type(attrs_json, '$.${k}') AS t${i2}`).join("");
-          stmt = this.db.prepare(
+          stmt2 = this.db.prepare(
             `SELECT id, description, community, extraction_confidence${cols} FROM nodes WHERE label = ? AND valid_to IS NULL`
           );
-          this.fieldStmts.set(cacheKey2, stmt);
+          this.fieldStmts.set(cacheKey2, stmt2);
         }
-        return stmt.all(label).map((r) => {
+        return stmt2.all(label).map((r) => {
           const attrs = {};
           attrKeys.forEach((k, i2) => {
             const v = decodeAttr(r[`a${i2}`], r[`t${i2}`]);
@@ -21029,14 +21206,14 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
       }
       nodeLabels(ids) {
         const width = NODE_LABELS_CHUNK;
-        const stmt = this.typedEdgeStmt(
+        const stmt2 = this.typedEdgeStmt(
           `SELECT id, label FROM nodes WHERE id IN (${Array.from({ length: width }, () => "?").join(",")})`
         );
         const labels = /* @__PURE__ */ new Map();
         for (let i2 = 0; i2 < ids.length; i2 += width) {
           const chunk = ids.slice(i2, i2 + width);
           while (chunk.length < width) chunk.push(null);
-          for (const row of stmt.all(...chunk)) labels.set(row.id, row.label);
+          for (const row of stmt2.all(...chunk)) labels.set(row.id, row.label);
         }
         return labels;
       }
@@ -21235,12 +21412,12 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
         return scale;
       }
       typedEdgeStmt(sql) {
-        let stmt = this.typedEdgeStmts.get(sql);
-        if (!stmt) {
-          stmt = this.db.prepare(sql);
-          this.typedEdgeStmts.set(sql, stmt);
+        let stmt2 = this.typedEdgeStmts.get(sql);
+        if (!stmt2) {
+          stmt2 = this.db.prepare(sql);
+          this.typedEdgeStmts.set(sql, stmt2);
         }
-        return stmt;
+        return stmt2;
       }
       outEdges(nodeId, types) {
         if (!types || types.length === 0) {
@@ -21441,22 +21618,28 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
         }
       }
       reviveReobserved(relPaths, workspaceId2, since) {
-        let revived = 0;
+        const revived = [];
         const CHUNK2 = 400;
         for (let i2 = 0; i2 < relPaths.length; i2 += CHUNK2) {
           const slice = relPaths.slice(i2, i2 + CHUNK2);
           if (slice.length === 0) continue;
-          const r = this.db.prepare(
-            `UPDATE nodes SET valid_to = NULL
+          const rows = this.db.prepare(
+            `SELECT id, valid_to AS closedAt, COALESCE(logical_id, id) AS lid FROM nodes
              WHERE valid_to IS NOT NULL
                AND last_updated_at >= ?
                AND json_extract(attrs_json, '$.workspaceId') = ?
-               AND json_extract(attrs_json, '$.relPath') IN (${slice.map(() => "?").join(",")})`
-          ).run(since, workspaceId2, ...slice);
-          revived += Number(r.changes);
-        }
-        if (revived > 0) this.mutations++;
-        return revived;
+               AND json_extract(attrs_json, '$.relPath') IN (${slice.map(() => "?").join(",")})
+               AND json_type(attrs_json, '$.historical') IS NOT 'true'`
+          ).all(since, workspaceId2, ...slice);
+          revived.push(...rows);
+        }
+        if (revived.length === 0) return 0;
+        const reopen = this.db.prepare("UPDATE nodes SET valid_to = NULL WHERE id = ? AND valid_to IS NOT NULL");
+        for (const r of revived) reopen.run(r.id);
+        for (const r of revived) reopenCascadeClosedEdges(this.db, r.id, Number(r.closedAt));
+        collapseLiveHeads(this.db, revived.map((r) => r.lid), since);
+        this.mutations++;
+        return revived.length;
       }
       incomingEdgeCoverage(label, edgeTypes, cloudOnly) {
         if (edgeTypes.length === 0) return { count: 0, total: 0 };
@@ -21602,8 +21785,9 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
         this.stmts.advanceLive.run({ live_id: liveId, t });
         return frozenId;
       }
-      closeNode(id, t) {
-        this.stmts.closeNode.run({ id, t });
+      closeNode(id, t, opts = {}) {
+        const r = this.stmts.closeNode.run({ id, t });
+        if (Number(r.changes) > 0 && !opts.retainEdges) closeIncidentEdges(this.db, id, t);
       }
       closeEdge(id, t) {
         this.stmts.closeEdge.run({ id, t });
@@ -23579,7 +23763,7 @@ function reinforceSameAnchorProblem(store, relPath, workspaceId2, statement, sou
 }
 function foldSameAnchorProblem(store, relPath, workspaceId2, statement, source, ts, kind = "problem") {
   const report = { ...EMPTY_FOLD_REPORT };
-  const stmt = statement.trim();
+  const stmt2 = statement.trim();
   if (!isAnchorableCodePath(relPath)) {
     report.noFile = true;
     return report;
@@ -23589,7 +23773,7 @@ function foldSameAnchorProblem(store, relPath, workspaceId2, statement, source,
     report.noFile = true;
     return report;
   }
-  const selfId = identityId({ kind: "DesignProblem", statement: stmt });
+  const selfId = identityId({ kind: "DesignProblem", statement: stmt2 });
   let stmtVec = null;
   let best = null;
   let bestScout = null;
@@ -23603,11 +23787,11 @@ function foldSameAnchorProblem(store, relPath, workspaceId2, statement, source,
       continue;
     }
     report.candidates++;
-    const score2 = tokenJaccard(stmt, cand.description);
+    const score2 = tokenJaccard(stmt2, cand.description);
     if (score2 > report.bestJaccard) report.bestJaccard = score2;
     if (score2 >= SAME_ANCHOR_DEDUP_JACCARD && (!best || score2 > best.score)) best = { node: cand, score: score2 };
     if (!best) {
-      stmtVec ??= embed(stmt);
+      stmtVec ??= embed(stmt2);
       const hc = cosine(stmtVec, embed(cand.description));
       if (hc > report.bestHashCos) report.bestHashCos = hc;
       if ((hc >= SAME_ANCHOR_SCOUT_MIN_COSINE || score2 >= SAME_ANCHOR_NOMINATE_JACCARD) && (!bestScout || hc > bestScout.hashCos)) {
@@ -23654,11 +23838,11 @@ function foldSameAnchorProblem(store, relPath, workspaceId2, statement, source,
   return report;
 }
 function findResolvedAnchorMatch(store, relPath, workspaceId2, statement, kind = "problem") {
-  const stmt = statement.trim();
+  const stmt2 = statement.trim();
   if (!isAnchorableCodePath(relPath)) return null;
   const file2 = resolveFileNode(store, relPath, workspaceId2);
   if (!file2) return null;
-  const selfId = identityId({ kind: "DesignProblem", statement: stmt });
+  const selfId = identityId({ kind: "DesignProblem", statement: stmt2 });
   let best = null;
   for (const e of store.inEdges(file2.id, ["ANCHORED_AT"])) {
     const cand = store.getNode(e.from);
@@ -23668,7 +23852,7 @@ function findResolvedAnchorMatch(store, relPath, workspaceId2, statement, kind =
     if (cand.id === selfId) continue;
     const candKind = cand.attrs["kind"] === "constraint" ? "constraint" : "problem";
     if (candKind !== (kind === "constraint" ? "constraint" : "problem")) continue;
-    const score2 = tokenJaccard(stmt, cand.description);
+    const score2 = tokenJaccard(stmt2, cand.description);
     if (score2 >= SAME_ANCHOR_DEDUP_JACCARD && (!best || score2 > best.score)) {
       best = { id: cand.id, score: score2 };
     }
@@ -26042,6 +26226,20 @@ function clearCandidate(store, node2, ts, rejectTargetId) {
   }
   store.updateNode(node2.id, { attrs, lastUpdatedAt: ts });
 }
+function markStanding(store, node2, mark, reason, ts) {
+  const stamped = {
+    ...mark,
+    examinedAtSeq: store.currentIngestSeq(),
+    examinations: (mark.examinations ?? 0) + 1,
+    standingReason: reason
+  };
+  store.updateNode(node2.id, { attrs: { ...node2.attrs, foldCandidate: stamped }, lastUpdatedAt: ts });
+}
+function foldCandidateEligible(mark, currentSeq, judgeConfigured) {
+  if (mark.examinedAtSeq === void 0) return true;
+  if (mark.standingReason === "no-judge" && judgeConfigured) return true;
+  return currentSeq - mark.examinedAtSeq >= FOLD_REEXAMINE_SEQ;
+}
 async function resolveFoldCandidates(store, opts) {
   const report = {
     examined: 0,
@@ -26051,10 +26249,17 @@ async function resolveFoldCandidates(store, opts) {
     rejected: 0,
     standing: 0,
     judgeErrors: 0,
-    retargeted: 0
+    retargeted: 0,
+    pending: 0,
+    neverExamined: 0,
+    firstExamined: 0,
+    waiting: 0,
+    judgeBudgetDeferred: 0
   };
-  const limit = opts.limit ?? 8;
-  const marked = store.selectNodes({
+  const limit = opts.limit ?? FOLD_EXAMINE_LIMIT;
+  const judgeBudget = opts.judgeBudget ?? FOLD_JUDGE_BUDGET;
+  const currentSeq = store.currentIngestSeq();
+  const pool = store.selectNodes({
     labels: ["Problem"],
     attrs: ["foldCandidate"],
     where: [
@@ -26062,16 +26267,35 @@ async function resolveFoldCandidates(store, opts) {
       { attr: "mergedInto", absent: true },
       { attr: "foldCandidate", present: true }
     ]
-  }).sort((a, b) => {
-    const ma = a.attrs["foldCandidate"].ts ?? 0;
-    const mb = b.attrs["foldCandidate"].ts ?? 0;
-    return ma - mb;
+  });
+  const markOf = (n) => n.attrs["foldCandidate"];
+  report.pending = pool.length;
+  let neverExamined = pool.filter((n) => markOf(n).examinedAtSeq === void 0).length;
+  const eligible = pool.filter((n) => foldCandidateEligible(markOf(n), currentSeq, !!opts.judge));
+  report.waiting = pool.length - eligible.length;
+  const marked = eligible.sort((a, b) => {
+    const ma = markOf(a);
+    const mb = markOf(b);
+    const ea = ma.examinedAtSeq ?? -1;
+    const eb = mb.examinedAtSeq ?? -1;
+    if (ea !== eb) return ea - eb;
+    return (ma.ts ?? 0) - (mb.ts ?? 0);
   }).slice(0, limit);
+  let judgeCalls = 0;
+  const unseenMark = (n) => {
+    const m = n.attrs["foldCandidate"];
+    return m !== void 0 && m.examinedAtSeq === void 0;
+  };
   for (const node2 of marked) {
     const fresh = store.getNode(node2.id);
     if (!openProblem(fresh)) continue;
-    report.examined++;
     const mark = fresh.attrs["foldCandidate"];
+    const firstLook = mark.examinedAtSeq === void 0;
+    report.examined++;
+    if (firstLook) {
+      report.firstExamined++;
+      neverExamined--;
+    }
     let target = followMerges(store, mark.targetId);
     if (target && target.id !== mark.targetId) report.retargeted++;
     if (!openProblem(target)) {
@@ -26089,6 +26313,7 @@ async function resolveFoldCandidates(store, opts) {
       cos = cosine(fresh.embedding, target.embedding);
     }
     if (cos !== null && cos >= FOLD_EMBED_AUTO_COSINE) {
+      if (unseenMark(target)) neverExamined--;
       foldPair(store, fresh, target, opts.ts);
       report.folded++;
       report.foldedEmbedding++;
@@ -26100,9 +26325,20 @@ async function resolveFoldCandidates(store, opts) {
       continue;
     }
     if (!opts.judge) {
+      markStanding(store, fresh, mark, "no-judge", opts.ts);
       report.standing++;
       continue;
     }
+    if (judgeCalls >= judgeBudget) {
+      report.examined--;
+      if (firstLook) {
+        report.firstExamined--;
+        neverExamined++;
+      }
+      report.judgeBudgetDeferred++;
+      continue;
+    }
+    judgeCalls++;
     let verdict = null;
     try {
       verdict = await opts.judge(fresh.description, target.description);
@@ -26110,6 +26346,7 @@ async function resolveFoldCandidates(store, opts) {
       verdict = null;
     }
     if (verdict === "same") {
+      if (unseenMark(target)) neverExamined--;
       foldPair(store, fresh, target, opts.ts);
       report.folded++;
       report.foldedJudge++;
@@ -26117,10 +26354,12 @@ async function resolveFoldCandidates(store, opts) {
       clearCandidate(store, fresh, opts.ts, target.id);
       report.rejected++;
     } else {
+      markStanding(store, fresh, mark, "judge-error", opts.ts);
       report.judgeErrors++;
       report.standing++;
     }
   }
+  report.neverExamined = neverExamined;
   return report;
 }
 function foldPair(store, a, b, ts) {
@@ -26135,7 +26374,7 @@ function foldPair(store, a, b, ts) {
   if (!freshSurvivor || !freshDup) return;
   foldDuplicateProblem(store, freshDup, freshSurvivor, ts);
 }
-var FOLD_SCOUT_AUTO_COSINE, FOLD_SCOUT_MIN_COSINE, FOLD_SCOUT_MIN_JACCARD, FOLD_EMBED_AUTO_COSINE, FOLD_JUDGE_MIN_COSINE, FOLD_REJECTED_CAP, WORKSPACE_SCAN_CAP, openProblem;
+var FOLD_SCOUT_AUTO_COSINE, FOLD_SCOUT_MIN_COSINE, FOLD_SCOUT_MIN_JACCARD, FOLD_EMBED_AUTO_COSINE, FOLD_JUDGE_MIN_COSINE, FOLD_REJECTED_CAP, FOLD_REEXAMINE_SEQ, FOLD_EXAMINE_LIMIT, FOLD_JUDGE_BUDGET, WORKSPACE_SCAN_CAP, openProblem;
 var init_fold_candidates = __esm({
   "../../packages/local-graph/src/fold-candidates.ts"() {
     "use strict";
@@ -26148,6 +26387,9 @@ var init_fold_candidates = __esm({
     FOLD_EMBED_AUTO_COSINE = 0.88;
     FOLD_JUDGE_MIN_COSINE = 0.5;
     FOLD_REJECTED_CAP = 8;
+    FOLD_REEXAMINE_SEQ = 100;
+    FOLD_EXAMINE_LIMIT = 32;
+    FOLD_JUDGE_BUDGET = 8;
     WORKSPACE_SCAN_CAP = 400;
     openProblem = (n) => !!n && n.label === "Problem" && n.attrs["resolvedAt"] == null && n.attrs["mergedInto"] === void 0;
   }
@@ -26606,6 +26848,28 @@ var init_mechanism_liveness = __esm({
         // climbs while `accepted` stays flat is the shape of a silently-closed door.
         backlogCounter: "candidates"
       },
+      {
+        id: "edge-park-replay",
+        what: "parks causal/anchor edges the door refused as unresolvable, replays them when due, drops them with a disposition",
+        pass: "ship",
+        // FED = a source whose whole binding-edge family LANDED: the digest is
+        // stamped only when every edge in it came back created/reinforced, so it is
+        // the store-side proof that edges (not just nodes) cross. Live dev
+        // 2026-10-12 sat with the same 241 refusals re-sent every drain and this
+        // stamp frozen — nodes crossed, their causal wiring did not.
+        fed: {
+          labels: ["Problem", "RootCause"],
+          attr: "semanticEdgesContributedDigest",
+          minFraction: 0.01
+        },
+        // A parked edge that later LANDED — the replay doing its job.
+        effectCounter: "edgesReplayLanded",
+        // Outstanding parked edges (a level). Flat-and-nonzero while replays keep
+        // re-parking is an endpoint that never resolves; it drains to tombstones
+        // (`edgesDroppedExhausted`) instead of being resent forever.
+        backlogCounter: "edgeParkSize",
+        note: "edge-park.ts; quiet (no-effect) is healthy when nothing is refused \u2014 read edgesParked/edgesDropped* on the ship row"
+      },
       {
         id: "orphan-reap",
         what: "closes File nodes whose path the indexer no longer covers",
@@ -26660,12 +26924,31 @@ var init_mechanism_liveness = __esm({
         // the bar is "the field is written at all", the revisit-sweep precedent.
         fed: { labels: ["Problem"], attr: "foldCandidate", minFraction: 0 },
         effectCounter: "folded",
-        // Standing nominations ARE the judge-less backlog — without the gauge a
-        // deployment with no judge configured reads as "nothing to fold".
-        backlogCounter: "standing",
+        // The open-nomination POOL is the backlog. It used to be `standing`, which
+        // only counts what the pass examined — capped at the per-run limit — so it
+        // read a flat 8 for weeks while 824 nominations sat open (2026-10-12): the
+        // gauge could not see past the slice it was meant to be measuring.
+        backlogCounter: "pending",
         configCounter: "judgeConfigured",
         note: "the ambiguous band needs the opt-in judge: set ERRATA_FOLD_JUDGE=1 + a configured chat provider (azure env), or leave it off and the nominations stand"
       },
+      {
+        id: "fold-candidate-coverage",
+        what: "rotates the fold-judge pass through every open nomination (never-examined first, standing ones re-examined on new evidence)",
+        // Judge-INDEPENDENT on purpose — no configCounter. The embedding-certain
+        // bands fold/reject with no judge at all, and the defect this watches is
+        // the pass re-reading the same oldest 8 forever (101 runs, 8 distinct
+        // nodes, 816 of 824 nominations never looked at). That starves those
+        // bands on a judge-less daemon exactly as much as on a judged one, so an
+        // opt-in being off must not excuse it.
+        pass: "fold-judge",
+        fed: { labels: ["Problem"], attr: "foldCandidate", minFraction: 0 },
+        effectCounter: "firstExamined",
+        // A LEVEL: open nominations never examined. Flat-and-positive with no
+        // first examinations across the stall window = the rotation is stuck.
+        backlogCounter: "neverExamined",
+        note: "neverExamined must drain while the pass runs; flat means the selection is re-reading the same slice"
+      },
       {
         id: "cite-anchor-accrual",
         what: "accrues cite-context anchor evidence on anchorless cited priors; two distinct sessions promote a cite-confirmed ANCHORED_AT",
@@ -26845,13 +27128,18 @@ __export(src_exports2, {
   FINGERPRINT_INDEXED_LABELS: () => FINGERPRINT_INDEXED_LABELS,
   FIX_CANDIDATE_ASK_LIMIT: () => FIX_CANDIDATE_ASK_LIMIT,
   FOLD_EMBED_AUTO_COSINE: () => FOLD_EMBED_AUTO_COSINE,
+  FOLD_EXAMINE_LIMIT: () => FOLD_EXAMINE_LIMIT,
+  FOLD_JUDGE_BUDGET: () => FOLD_JUDGE_BUDGET,
   FOLD_JUDGE_MIN_COSINE: () => FOLD_JUDGE_MIN_COSINE,
+  FOLD_REEXAMINE_SEQ: () => FOLD_REEXAMINE_SEQ,
   FOLD_REJECTED_CAP: () => FOLD_REJECTED_CAP,
   FOLD_SCOUT_AUTO_COSINE: () => FOLD_SCOUT_AUTO_COSINE,
   FOLD_SCOUT_MIN_COSINE: () => FOLD_SCOUT_MIN_COSINE,
   FOLD_SCOUT_MIN_JACCARD: () => FOLD_SCOUT_MIN_JACCARD,
+  HISTORY_EDGE_TYPES: () => HISTORY_EDGE_TYPES,
   JOINT_COMMUNITY_EDGES: () => JOINT_COMMUNITY_EDGES,
   JOINT_COMMUNITY_LABELS: () => JOINT_COMMUNITY_LABELS,
+  LINEAGE_INTEGRITY_KEY: () => LINEAGE_INTEGRITY_KEY,
   MAX_ANCHOR_FILES: () => MAX_ANCHOR_FILES,
   MECHANISMS: () => MECHANISMS,
   MIN_INTENT_TOKENS: () => MIN_INTENT_TOKENS,
@@ -26893,11 +27181,15 @@ __export(src_exports2, {
   clearRevisit: () => clearRevisit,
   clearSettledFixCandidates: () => clearSettledFixCandidates,
   closableByCaller: () => closableByCaller,
+  closeIncidentEdges: () => closeIncidentEdges,
+  collapseLiveHeads: () => collapseLiveHeads,
   communityInductionRequests: () => communityInductionRequests,
   communitySeeds: () => communitySeeds,
   compareSemver: () => compareSemver,
   confirmFixHeld: () => confirmFixHeld,
   corroborateClaim: () => corroborateClaim,
+  countLiveHeadConflicts: () => countLiveHeadConflicts,
+  countStrandedEdges: () => countStrandedEdges,
   creditAssignment: () => creditAssignment,
   crystallize: () => crystallize,
   deriveContextFromAnchors: () => deriveContextFromAnchors,
@@ -26916,6 +27208,7 @@ __export(src_exports2, {
   findReusableSolution: () => findReusableSolution,
   findWorkspaceFoldCandidate: () => findWorkspaceFoldCandidate,
   flattenCloudCounts: () => flattenCloudCounts,
+  foldCandidateEligible: () => foldCandidateEligible,
   foldDuplicateProblem: () => foldDuplicateProblem,
   foldSameAnchorProblem: () => foldSameAnchorProblem,
   formatMechanismStatus: () => formatMechanismStatus,
@@ -26928,6 +27221,7 @@ __export(src_exports2, {
   induceTriage: () => induceTriage,
   ingestDesignProblem: () => ingestDesignProblem,
   ingestWitnessedVulnerability: () => ingestWitnessedVulnerability,
+  installLineageIntegrityRepair: () => installLineageIntegrityRepair,
   isConstraintProblem: () => isConstraintProblem,
   isFragmentFixNote: () => isFragmentFixNote,
   isPlaceholderStatement: () => isPlaceholderStatement,
@@ -26983,7 +27277,9 @@ __export(src_exports2, {
   reinforceSameAnchorProblem: () => reinforceSameAnchorProblem,
   relateClaims: () => relateClaims,
   reopenAutoClosedProblems: () => reopenAutoClosedProblems,
+  reopenCascadeClosedEdges: () => reopenCascadeClosedEdges,
   repairLegacyAnchorsFromStatement: () => repairLegacyAnchorsFromStatement,
+  repairLineageIntegrity: () => repairLineageIntegrity,
   resolveDesignProblemById: () => resolveDesignProblemById,
   resolveDesignProblemByStatement: () => resolveDesignProblemByStatement,
   resolveEnclosingSymbol: () => resolveEnclosingSymbol,
@@ -27033,6 +27329,7 @@ var init_src5 = __esm({
     init_tools();
     init_principle_sync();
     init_mechanism_liveness();
+    init_lineage_integrity();
     init_wm_calibration();
   }
 });
@@ -28469,7 +28766,7 @@ function parseRestErrorEnvelope(text) {
     return null;
   }
 }
-var asWireCount, INGEST_NODE_CHUNK, INGEST_EDGE_CHUNK, E6B_PUBLIC_CONTEXT_SENTINEL, gzipAsync, CloudClient, CloudError;
+var asWireCount, INGEST_NODE_CHUNK, INGEST_EDGE_CHUNK, ENDPOINT_NOT_LANDED_PREFIX, E6B_PUBLIC_CONTEXT_SENTINEL, gzipAsync, CloudClient, CloudError;
 var init_client = __esm({
   "../../packages/cloud-client/src/client.ts"() {
     "use strict";
@@ -28478,6 +28775,7 @@ var init_client = __esm({
     asWireCount = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0 ? Math.floor(n) : null;
     INGEST_NODE_CHUNK = 8;
     INGEST_EDGE_CHUNK = 32;
+    ENDPOINT_NOT_LANDED_PREFIX = "endpoint did not land this drain";
     E6B_PUBLIC_CONTEXT_SENTINEL = "00000000-0000-4e6b-8000-000000000e6b";
     gzipAsync = promisify(gzip);
     CloudClient = class {
@@ -28680,7 +28978,7 @@ var init_client = __esm({
           pendingEdges = pendingEdges.filter((e) => !shipped.has(e));
           return { nodes, edges };
         });
-        const totalChunks = single ? 1 : nodePlan.length + Math.ceil(pendingEdges.length / INGEST_EDGE_CHUNK);
+        let totalChunks = single ? 1 : nodePlan.length + Math.ceil(pendingEdges.length / INGEST_EDGE_CHUNK);
         let chunkIndex = 0;
         const blocked = [];
         const emit = async (nodeIds, result) => {
@@ -28707,9 +29005,18 @@ var init_client = __esm({
         }
         const merged = { runId, nodes: [], edges: [] };
         const echoedCloudId = /* @__PURE__ */ new Map();
+        const notLanded = /* @__PURE__ */ new Map();
         for (const { nodes: nodeChunk, edges: inChunk } of nodePlan) {
           const r = await this.ingestWithSplit(batch, nodeChunk, inChunk, blocked);
+          const refusedHere = new Set(blocked);
           await emit(nodeChunk.map((n) => n.id), r);
+          const verdict = new Map(r.nodes.map((rn) => [rn.canonicalId, rn]));
+          for (const n of nodeChunk) {
+            const rn = verdict.get(n.id);
+            if (refusedHere.has(n.id)) notLanded.set(n.id, "refused by an intermediary");
+            else if (!rn) notLanded.set(n.id, "no verdict from the door");
+            else if (rn.decision === "rejected") notLanded.set(n.id, rn.reason ?? "rejected");
+          }
           merged.nodes.push(...r.nodes);
           merged.edges.push(...r.edges);
           for (const rn of r.nodes) {
@@ -28721,6 +29028,19 @@ var init_client = __esm({
             merged.patternReconciliation = { ...merged.patternReconciliation, ...r.patternReconciliation };
           }
         }
+        pendingEdges = pendingEdges.filter((e) => {
+          const missing = notLanded.has(e.from) && !echoedCloudId.has(e.from) ? e.from : notLanded.has(e.to) && !echoedCloudId.has(e.to) ? e.to : null;
+          if (missing === null) return true;
+          merged.edges.push({
+            from: e.from,
+            to: e.to,
+            type: e.type,
+            decision: "rejected",
+            reason: `${ENDPOINT_NOT_LANDED_PREFIX} '${missing}' \u2014 ${notLanded.get(missing)}`
+          });
+          return false;
+        });
+        totalChunks = nodePlan.length + Math.ceil(pendingEdges.length / INGEST_EDGE_CHUNK);
         for (const edgeChunk of chunkArray(pendingEdges, INGEST_EDGE_CHUNK)) {
           const projected = edgeChunk.map((e) => ({
             ...e,
@@ -33296,7 +33616,7 @@ function detectResolution(opts, ev) {
 function closeProblem(store, problemId, t) {
   const n = store.getNode(problemId);
   if (!n || (n.validTo ?? null) !== null) return false;
-  store.closeNode(problemId, t);
+  store.closeNode(problemId, t, { retainEdges: true });
   store.updateNode(problemId, { attrs: { ...n.attrs, resolvedAt: t } });
   return true;
 }
@@ -37988,9 +38308,11 @@ async function incrementalReindex(store, rootPath, workspaceId2, changedAbsPaths
       signatureAfter: a.signature
     });
   }
+  const repointable = /* @__PURE__ */ new Map();
   store.transaction(() => {
     for (const nid of changedIds) store.freezeNode(nid, t);
     for (const nid of removedIds) {
+      repointable.set(nid, store.inEdges(nid, ["CALLS", "ACCESSES", "ANCHORED_AT"]));
       for (const e of store.outEdges(nid)) store.closeEdge(e.id, t);
       store.closeNode(nid, t);
     }
@@ -38079,8 +38401,8 @@ async function incrementalReindex(store, rootPath, workspaceId2, changedAbsPaths
             version: b.version + 1
           });
           store.mergeEdge(continuesEdge(m, t));
-          for (const e of store.inEdges(m.fromNid, ["CALLS", "ACCESSES", "ANCHORED_AT"])) {
-            if (e.validTo != null) continue;
+          for (const e of repointable.get(m.fromNid) ?? []) {
+            if (e.from === m.fromNid || !store.liveNodeIds([e.from]).has(e.from)) continue;
             const newId = edgeId(e.from, e.type, m.toNid);
             if (!store.getEdge(newId)) {
               store.mergeEdge({ ...e, id: newId, to: m.toNid, lastSeenAt: t });
@@ -44172,10 +44494,10 @@ function collectDocstrings(root, records, out2) {
     }
   }
 }
-function docstringIn(stmt) {
-  if (!stmt) return null;
-  if (stmt.type !== "expression_statement") return null;
-  const expr = stmt.namedChild(0);
+function docstringIn(stmt2) {
+  if (!stmt2) return null;
+  if (stmt2.type !== "expression_statement") return null;
+  const expr = stmt2.namedChild(0);
   if (!expr) return null;
   if (expr.type !== "string") return null;
   const text = expr.text;
@@ -47773,7 +48095,7 @@ var init_mcp = __esm({
       },
       {
         name: "errata.health",
-        description: "Graph-quality + backlog snapshot \u2014 the dashboard's health view, for an agent. Returns counts of: stranded symbols (a live edge points at a non-live node \u2014 invisible to name resolution), open Problems, open Problems with NO proposed fix, retracted false-positives + dissolutions (the agentic-misread rate \u2014 PLAN_RETRACTION \xA7D), ungrounded-but-'derived' Claims (belief-layer noise), and facts needing revisit. Use to triage the workspace's state or sanity-check the graph before trusting a transitive answer.",
+        description: "Graph-quality + backlog snapshot \u2014 the dashboard's health view, for an agent. Returns counts of: stranded symbols (a live File DEFINES/CONTAINS edge points at a non-live node \u2014 invisible to name resolution), stranded edges (ANY live non-history edge with a closed endpoint, by type), lineages with more than one live head, open Problems, open Problems with NO proposed fix, retracted false-positives + dissolutions (the agentic-misread rate \u2014 PLAN_RETRACTION \xA7D), ungrounded-but-'derived' Claims (belief-layer noise), and facts needing revisit. Use to triage the workspace's state or sanity-check the graph before trusting a transitive answer.",
         inputSchema: { type: "object", properties: {} },
         handler: (_args, store) => {
           const unresolved2 = store.selectNodes({
@@ -47786,10 +48108,16 @@ var init_mcp = __esm({
           const noFix = open2.filter((p) => store.outEdges(p.id, ["SOLVED_BY"]).length === 0);
           const retracted = (resolvedAs) => store.countNodes({ labels: ["Problem"], includeClosed: true, where: [{ attr: "resolvedAs", eq: resolvedAs }] });
           const ungroundedDerived = store.selectNodes({ labels: ["Claim"], attrs: ["groundedSupport"], where: [{ attr: "crystallized", eq: "derived" }] }).filter((c) => Number(c.attrs["groundedSupport"] ?? 0) === 0);
+          const stranded = store.strandedEdges();
           return {
             nodes: store.nodeCount(),
             edges: store.edgeCount(),
             strandedSymbols: findStrandedSymbols(store).length,
+            // strandedSymbols only sees File-rooted lineage; it read 0 while ~105k
+            // live edges hung off closed nodes (2026-10-12). This counts all of them.
+            strandedEdges: stranded.total,
+            strandedEdgesByType: stranded.byType,
+            liveHeadConflicts: store.liveHeadConflicts(),
             openProblems: open2.length,
             openProblemsWithoutFix: noFix.length,
             designConstraints: constraints.length,
@@ -48443,10 +48771,15 @@ function formatHotspotsMd(r) {
   }
   return lines.join("\n") + "\n";
 }
+function strandedTypes(byType) {
+  const top = Object.entries(byType ?? {}).sort((a, b) => b[1] - a[1]).slice(0, 3);
+  return top.length ? ` (${top.map(([t, n]) => `${t} ${n}`).join(", ")})` : "";
+}
 function formatHealthMd(r) {
   return `${head("health")}
 nodes ${r.nodes} \xB7 edges ${r.edges}
 stranded symbols: ${r.strandedSymbols}
+stranded edges: ${r.strandedEdges ?? 0}${strandedTypes(r.strandedEdgesByType)} \xB7 lineages with >1 live head: ${r.liveHeadConflicts ?? 0}
 open problems: ${r.openProblems} (${r.openProblemsWithoutFix} without a proposed fix)
 retracted: ${r.retractedFalsePositive} false-positive \xB7 ${r.retractedDissolution} dissolution
 ungrounded "derived" claims: ${r.ungroundedDerivedClaims}
@@ -76427,8 +76760,8 @@ var init_report_render = __esm({
 
 // src/cli.ts
 init_src6();
-import { closeSync as closeSync3, existsSync as existsSync40, openSync as openSync3, readFileSync as readFileSync43, renameSync as renameSync8, statSync as statSync13 } from "node:fs";
-import { join as join50, resolve as pathResolve2 } from "node:path";
+import { closeSync as closeSync3, existsSync as existsSync40, openSync as openSync3, readFileSync as readFileSync44, renameSync as renameSync9, statSync as statSync13 } from "node:fs";
+import { join as join51, resolve as pathResolve2 } from "node:path";
 import { spawn as spawn5 } from "node:child_process";
 
 // src/daemon.ts
@@ -77893,9 +78226,9 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname18 = sysPath.dirname(file2);
+    const dirname19 = sysPath.dirname(file2);
     const basename10 = sysPath.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname18);
+    const parent = this.fsw._getWatchedDir(dirname19);
     let prevStats = stats;
     if (parent.has(basename10))
       return;
@@ -77922,7 +78255,7 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error48) {
-          this.fsw._remove(dirname18, basename10);
+          this.fsw._remove(dirname19, basename10);
         }
       } else if (parent.has(basename10)) {
         const at = newStats.atimeMs;
@@ -81472,15 +81805,15 @@ function alreadyDone(configDir) {
   }
 }
 function replay(root) {
-  const statements = /* @__PURE__ */ new Set();
+  const statements2 = /* @__PURE__ */ new Set();
   const citedByFix = /* @__PURE__ */ new Set();
   const dir = claudeProjectDir(root, homedir5());
-  if (!existsSync20(dir)) return { statements, citedByFix };
+  if (!existsSync20(dir)) return { statements: statements2, citedByFix };
   let names;
   try {
     names = readdirSync8(dir).filter((n) => n.endsWith(".jsonl"));
   } catch {
-    return { statements, citedByFix };
+    return { statements: statements2, citedByFix };
   }
   for (const f of names) {
     let lines;
@@ -81501,7 +81834,7 @@ function replay(root) {
       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 === "constraint" && tag.statement) statements2.add(tag.statement);
           if (tag.kind === "fix") {
             const t = tag;
             if (t.handle) citedByFix.add(t.handle);
@@ -81511,11 +81844,11 @@ function replay(root) {
       }
     }
   }
-  return { statements, citedByFix };
+  return { statements: statements2, citedByFix };
 }
 function backfillConstraintKind(store, opts) {
   if (!opts.force && !opts.dryRun && alreadyDone(opts.configDir)) return EMPTY;
-  const { statements, citedByFix } = replay(opts.root);
+  const { statements: statements2, citedByFix } = replay(opts.root);
   const report = {
     skipped: false,
     stamped: 0,
@@ -81529,7 +81862,7 @@ function backfillConstraintKind(store, opts) {
   const missing = [];
   const seen = /* @__PURE__ */ new Set();
   const work = [];
-  for (const statement of statements) {
+  for (const statement of statements2) {
     const id = designProblemId(statement);
     if (seen.has(id)) continue;
     seen.add(id);
@@ -85836,7 +86169,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.22-dev.4173" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.22-dev.4186" : "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;
@@ -88357,7 +88690,12 @@ B: ${b}`,
           standing: fj.standing,
           judgeErrors: fj.judgeErrors,
           retargeted: fj.retargeted,
-          judgeConfigured: foldJudge ? 1 : 0
+          judgeConfigured: foldJudge ? 1 : 0,
+          pending: fj.pending,
+          neverExamined: fj.neverExamined,
+          firstExamined: fj.firstExamined,
+          waiting: fj.waiting,
+          judgeBudgetDeferred: fj.judgeBudgetDeferred
         });
         if (fj.folded > 0) {
           console.log(`[errata] fold-judge: folded ${fj.folded} paraphrase pair(s) (${fj.foldedEmbedding} by embedding, ${fj.foldedJudge} by judge), ${fj.standing} standing`);
@@ -88821,6 +89159,212 @@ async function linkRegisteredWorkspaces(cfg, loggedInProfile = cfg.activeInstall
   }
 }
 
+// src/edge-park.ts
+import { readFileSync as readFileSync33, renameSync as renameSync5, writeFileSync as writeFileSync25 } from "node:fs";
+import { dirname as dirname13, join as join36 } from "node:path";
+var EDGE_PARK_CAP = 2e3;
+var EDGE_PARK_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
+var EDGE_PARK_MAX_ATTEMPTS = 6;
+var EDGE_RETRY_BASE_MS = 30 * 60 * 1e3;
+var EDGE_RETRY_MAX_MS = 12 * 60 * 60 * 1e3;
+var EDGE_TOMBSTONE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+var EDGE_EXHAUSTED_TOMBSTONE_TTL_MS = 3 * 24 * 60 * 60 * 1e3;
+function tombstoneTtl(e) {
+  return e.dropReason === "refused" ? EDGE_TOMBSTONE_TTL_MS : EDGE_EXHAUSTED_TOMBSTONE_TTL_MS;
+}
+function wireEdgeKey(from, type, to) {
+  return JSON.stringify([from, type, to]);
+}
+function edgeParkPath(workspaceConfigDir, destinationKey) {
+  return join36(workspaceConfigDir, `edge-park.${destinationKey.slice(0, 16)}.json`);
+}
+function loadEdgePark(path3) {
+  let raw2;
+  try {
+    raw2 = JSON.parse(readFileSync33(path3, "utf8"));
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(raw2)) return [];
+  return raw2.filter(
+    (e) => !!e && typeof e === "object" && typeof e.key === "string" && typeof e.from === "string" && typeof e.to === "string" && typeof e.type === "string" && (e.state === "parked" || e.state === "dropped")
+  );
+}
+function saveEdgePark(path3, queue) {
+  try {
+    const tmp = join36(dirname13(path3), `.${Date.now()}.edge-park.tmp`);
+    writeFileSync25(tmp, JSON.stringify(queue), "utf8");
+    renameSync5(tmp, path3);
+  } catch {
+  }
+}
+function edgeHolds(queue, now) {
+  const holds = {};
+  for (const e of queue) {
+    if (e.state === "dropped") {
+      if (now - (e.droppedAt ?? e.ts) < tombstoneTtl(e)) holds[e.key] = "dropped";
+    } else if (e.dueAt > now) {
+      holds[e.key] = "held";
+    }
+  }
+  return holds;
+}
+function classifyEdgeVerdict(decision, reason) {
+  if (decision === "created" || decision === "reinforced") return "landed";
+  const why = reason ?? "";
+  if (/^unresolved endpoint\b/.test(why) || /^endpoint did not land this drain\b/.test(why) || /\bretry\b/i.test(why)) {
+    return "park";
+  }
+  return "drop";
+}
+function matchEdgeVerdicts(sent, received, echo) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const r of received) {
+    const k = wireEdgeKey(r.from, r.type, r.to);
+    if (!byKey.has(k) || r.decision === "rejected") byKey.set(k, { decision: r.decision, reason: r.reason });
+  }
+  const out2 = /* @__PURE__ */ new Map();
+  for (const e of sent) {
+    const v = byKey.get(wireEdgeKey(echo.get(e.from) ?? e.from, e.type, echo.get(e.to) ?? e.to)) ?? byKey.get(wireEdgeKey(e.from, e.type, e.to));
+    if (v) out2.set(e.id, v);
+  }
+  return out2;
+}
+function zeroEdgeSettleCounts(queue) {
+  const parked = queue.filter((e) => e.state === "parked").length;
+  return {
+    edgesSent: 0,
+    edgesLanded: 0,
+    edgesReplayLanded: 0,
+    edgesReplayed: 0,
+    edgesParked: 0,
+    edgesReparked: 0,
+    edgesDroppedRefused: 0,
+    edgesDroppedExhausted: 0,
+    edgesDroppedExpired: 0,
+    edgesDroppedCapped: 0,
+    edgesNoVerdict: 0,
+    edgeParkSize: parked,
+    edgeTombstones: queue.length - parked
+  };
+}
+function backoff(attempts) {
+  return Math.min(EDGE_RETRY_MAX_MS, EDGE_RETRY_BASE_MS * 2 ** Math.max(0, attempts - 1));
+}
+function settleEdgeOutcomes(queue, sent, verdicts, now) {
+  const counts = {
+    edgesSent: sent.length,
+    edgesLanded: 0,
+    edgesReplayLanded: 0,
+    edgesReplayed: 0,
+    edgesParked: 0,
+    edgesReparked: 0,
+    edgesDroppedRefused: 0,
+    edgesDroppedExhausted: 0,
+    edgesDroppedExpired: 0,
+    edgesDroppedCapped: 0,
+    edgesNoVerdict: 0,
+    edgeParkSize: 0,
+    edgeTombstones: 0
+  };
+  const byKey = new Map(queue.map((e) => [e.key, { ...e }]));
+  const seen = /* @__PURE__ */ new Set();
+  for (const e of sent) {
+    const key = e.id;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const prior = byKey.get(key);
+    if (prior?.state === "parked") counts.edgesReplayed++;
+    const v = verdicts.get(key);
+    if (!v) {
+      counts.edgesNoVerdict++;
+      continue;
+    }
+    const disposition = classifyEdgeVerdict(v.decision, v.reason);
+    if (disposition === "landed") {
+      counts.edgesLanded++;
+      if (prior) {
+        byKey.delete(key);
+        if (prior.state === "parked") counts.edgesReplayLanded++;
+      }
+      continue;
+    }
+    const reason = v.reason ?? "rejected";
+    if (prior?.state === "dropped") continue;
+    if (disposition === "drop") {
+      byKey.set(key, {
+        key,
+        from: e.from,
+        type: e.type,
+        to: e.to,
+        ts: prior?.ts ?? now,
+        attempts: (prior?.attempts ?? 0) + 1,
+        lastReason: reason,
+        dueAt: now,
+        state: "dropped",
+        dropReason: "refused",
+        droppedAt: now
+      });
+      counts.edgesDroppedRefused++;
+      continue;
+    }
+    const attempts = (prior?.state === "parked" ? prior.attempts : 0) + 1;
+    const ts = prior?.state === "parked" ? prior.ts : now;
+    if (attempts >= EDGE_PARK_MAX_ATTEMPTS || now - ts >= EDGE_PARK_TTL_MS) {
+      const why = attempts >= EDGE_PARK_MAX_ATTEMPTS ? "exhausted" : "expired";
+      byKey.set(key, {
+        key,
+        from: e.from,
+        type: e.type,
+        to: e.to,
+        ts,
+        attempts,
+        lastReason: reason,
+        dueAt: now,
+        state: "dropped",
+        dropReason: why,
+        droppedAt: now
+      });
+      if (why === "exhausted") counts.edgesDroppedExhausted++;
+      else counts.edgesDroppedExpired++;
+      continue;
+    }
+    byKey.set(key, {
+      key,
+      from: e.from,
+      type: e.type,
+      to: e.to,
+      ts,
+      attempts,
+      lastReason: reason,
+      dueAt: now + backoff(attempts),
+      state: "parked"
+    });
+    if (prior?.state === "parked") counts.edgesReparked++;
+    else counts.edgesParked++;
+  }
+  const live3 = [];
+  for (const e of byKey.values()) {
+    if (e.state === "parked" && now - e.ts >= EDGE_PARK_TTL_MS) {
+      counts.edgesDroppedExpired++;
+      continue;
+    }
+    if (e.state === "dropped" && now - (e.droppedAt ?? e.ts) >= tombstoneTtl(e)) continue;
+    live3.push(e);
+  }
+  let next = live3;
+  if (next.length > EDGE_PARK_CAP) {
+    const over = next.length - EDGE_PARK_CAP;
+    const order = [...next].sort((a, b) => (a.state === b.state ? 0 : a.state === "dropped" ? -1 : 1) || a.ts - b.ts);
+    const evict = new Set(order.slice(0, over).map((e) => e.key));
+    counts.edgesDroppedCapped = order.slice(0, over).filter((e) => e.state === "parked").length;
+    next = next.filter((e) => !evict.has(e.key));
+  }
+  counts.edgeParkSize = next.filter((e) => e.state === "parked").length;
+  counts.edgeTombstones = next.length - counts.edgeParkSize;
+  return { queue: next, counts };
+}
+
 // src/instance-receipts.ts
 import { createHash as createHash18 } from "node:crypto";
 var INSTANCE_SEMANTIC_EDGE_TYPES = ["CAUSED_BY", "SOLVED_BY"];
@@ -88962,7 +89506,7 @@ function invalidateInstanceReceipt(current, destination, failedId, mirrorLegacy)
 // src/multi.ts
 init_dist();
 init_src5();
-import { existsSync as existsSync34, writeFileSync as writeFileSync27 } from "node:fs";
+import { existsSync as existsSync34, writeFileSync as writeFileSync28 } from "node:fs";
 import { resolve as pathResolve } from "node:path";
 
 // src/principle-sync.ts
@@ -88991,8 +89535,8 @@ init_reconcile();
 
 // src/lockfile-auto.ts
 init_src();
-import { existsSync as existsSync30, readFileSync as readFileSync33 } from "node:fs";
-import { join as join36 } from "node:path";
+import { existsSync as existsSync30, readFileSync as readFileSync34 } from "node:fs";
+import { join as join37 } from "node:path";
 
 // src/package-index.ts
 init_src();
@@ -89144,11 +89688,11 @@ function runLockfilePass(opts) {
     { file: "package-lock.json", parse: parsePackageLockJson }
   ];
   for (const c of candidates) {
-    const p = join36(opts.root, c.file);
+    const p = join37(opts.root, c.file);
     if (!existsSync30(p)) continue;
     let sbom;
     try {
-      sbom = c.parse(readFileSync33(p, "utf8"));
+      sbom = c.parse(readFileSync34(p, "utf8"));
     } catch {
       continue;
     }
@@ -89209,8 +89753,8 @@ init_profile2();
 init_session_registry();
 
 // src/public-symbols.ts
-import { readFileSync as readFileSync34, readdirSync as readdirSync12, existsSync as existsSync31 } from "node:fs";
-import { join as join37 } from "node:path";
+import { readFileSync as readFileSync35, readdirSync as readdirSync12, existsSync as existsSync31 } from "node:fs";
+import { join as join38 } from "node:path";
 var HEAD_BYTES = 8 * 1024;
 var INDEX_TTL_MS = 10 * 60 * 1e3;
 var MIN_SYMBOL_LEN = 4;
@@ -89243,20 +89787,20 @@ function bindingNames(clause) {
 function internalPackageNames(workspaceRoot) {
   const names = /* @__PURE__ */ new Set();
   const tryRead = (dir) => {
-    const pj = join37(dir, "package.json");
+    const pj = join38(dir, "package.json");
     if (!existsSync31(pj)) return;
     try {
-      const name2 = JSON.parse(readFileSync34(pj, "utf8")).name;
+      const name2 = JSON.parse(readFileSync35(pj, "utf8")).name;
       if (typeof name2 === "string" && name2.length > 0) names.add(name2);
     } catch {
     }
   };
   tryRead(workspaceRoot);
   for (const group of ["packages", "apps"]) {
-    const groupDir = join37(workspaceRoot, group);
+    const groupDir = join38(workspaceRoot, group);
     if (!existsSync31(groupDir)) continue;
     try {
-      for (const entry of readdirSync12(groupDir)) tryRead(join37(groupDir, entry));
+      for (const entry of readdirSync12(groupDir)) tryRead(join38(groupDir, entry));
     } catch {
     }
   }
@@ -89275,7 +89819,7 @@ function publicSymbolIndex(store, workspaceRoot, deps = {}) {
   }
   const readHead = deps.readHead ?? ((absPath) => {
     try {
-      return readFileSync34(absPath, "utf8").slice(0, HEAD_BYTES);
+      return readFileSync35(absPath, "utf8").slice(0, HEAD_BYTES);
     } catch {
       return "";
     }
@@ -89295,7 +89839,7 @@ function publicSymbolIndex(store, workspaceRoot, deps = {}) {
   }
   const symbols = /* @__PURE__ */ new Set();
   for (const rel of files) {
-    const head2 = readHead(join37(workspaceRoot, rel));
+    const head2 = readHead(join38(workspaceRoot, rel));
     if (!head2) continue;
     for (const re of [NAMED_IMPORT_RE, REQUIRE_RE]) {
       re.lastIndex = 0;
@@ -89520,7 +90064,9 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
     sidecarNoSummary: 0,
     fileRefsSubstituted: 0,
     fileRefLexiconMisses: 0,
-    collapsedEdges: 0
+    collapsedEdges: 0,
+    edgesHeldParked: 0,
+    edgesHeldDropped: 0
   };
   const sharedCauses = /* @__PURE__ */ new Map();
   const causalQueue = store.findNodeFieldsByLabel("Problem", ["source", "resolvedAs"]).filter((r) => r.attrs["source"] !== "cloud" && r.attrs["resolvedAs"] !== PROBLEM_RESOLUTION.FALSE_POSITIVE).map((r) => r.id).filter((id) => ignorePatterns.length === 0 || !ignored(store.getNode(id)?.description ?? ""));
@@ -89831,6 +90377,30 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
     if (count > 0) symbolSummaries = sidecar;
   }
   edges.push(...anchorEdges);
+  if (opts.edgeHolds && Object.keys(opts.edgeHolds).length > 0) {
+    const holds = opts.edgeHolds;
+    const shipsHere = (wireId) => (endpointSources[wireId] ?? [wireId]).some((localId) => shippedById.has(localId));
+    const kept = [];
+    for (const e of edges) {
+      const hold = holds[e.id];
+      if (!hold || hold === "held" && (shipsHere(e.from) || shipsHere(e.to))) {
+        kept.push(e);
+        continue;
+      }
+      if (hold === "held") {
+        composition.edgesHeldParked++;
+        for (const localId of endpointSources[e.from] ?? [e.from]) {
+          delete anchorDigests[localId];
+          delete semanticEdgeDigests[localId];
+          delete projectAnchorDigests[localId];
+        }
+      } else {
+        composition.edgesHeldDropped++;
+      }
+    }
+    edges.length = 0;
+    edges.push(...kept);
+  }
   const bindingEndpoints = /* @__PURE__ */ new Set();
   for (const e of edges) {
     if (e.type === "CAUSED_BY" || e.type === "SOLVED_BY") {
@@ -89996,7 +90566,8 @@ function buildDrainInstances(store, sharedStore, input) {
     ...lexicon ? { lexicon } : {},
     ...fileLexicon ? { fileLexicon } : {},
     ...input.project ? { project: input.project } : {},
-    ...input.quarantinedSessions?.length ? { quarantinedSessions: input.quarantinedSessions } : {}
+    ...input.quarantinedSessions?.length ? { quarantinedSessions: input.quarantinedSessions } : {},
+    ...input.edgeHolds ? { edgeHolds: input.edgeHolds } : {}
   });
   return {
     batch,
@@ -90253,7 +90824,7 @@ init_config();
 
 // src/update.ts
 import { spawn as spawn2 } from "node:child_process";
-import { isAbsolute as isAbsolute6, join as join38 } from "node:path";
+import { isAbsolute as isAbsolute6, join as join39 } 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());
@@ -90400,7 +90971,7 @@ async function runInstalledHookRefresh() {
   });
   if (!isAbsolute6(root)) return 1;
   return new Promise((resolve10) => {
-    const child = spawn2(process.execPath, [join38(root, PACKAGE_NAME, "errata.mjs"), "install-hooks", "codex", "--refresh-existing"], {
+    const child = spawn2(process.execPath, [join39(root, PACKAGE_NAME, "errata.mjs"), "install-hooks", "codex", "--refresh-existing"], {
       windowsHide: true,
       stdio: "inherit",
       timeout: 3e4
@@ -90546,12 +91117,12 @@ function landCloudEdge(store, e, from, to) {
 }
 
 // src/causal-edge-queue.ts
-import { readFileSync as readFileSync35, renameSync as renameSync5, writeFileSync as writeFileSync25 } from "node:fs";
-import { dirname as dirname13, join as join39 } from "node:path";
+import { readFileSync as readFileSync36, renameSync as renameSync6, writeFileSync as writeFileSync26 } from "node:fs";
+import { dirname as dirname14, join as join40 } from "node:path";
 var CAUSAL_EDGE_QUEUE_CAP = 5e3;
 var CAUSAL_EDGE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 function causalEdgeQueuePath(workspaceConfigDir) {
-  return join39(workspaceConfigDir, "causal-edge-queue.json");
+  return join40(workspaceConfigDir, "causal-edge-queue.json");
 }
 function parkedEdgeKey(e) {
   return `${e.from}|${e.type}|${e.to}`;
@@ -90559,7 +91130,7 @@ function parkedEdgeKey(e) {
 function loadCausalEdgeQueue(path3) {
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync35(path3, "utf8"));
+    raw2 = JSON.parse(readFileSync36(path3, "utf8"));
   } catch {
     return [];
   }
@@ -90570,9 +91141,9 @@ function loadCausalEdgeQueue(path3) {
 }
 function saveCausalEdgeQueue(path3, queue) {
   try {
-    const tmp = join39(dirname13(path3), `.${Date.now()}.causal-edge-queue.tmp`);
-    writeFileSync25(tmp, JSON.stringify(queue), "utf8");
-    renameSync5(tmp, path3);
+    const tmp = join40(dirname14(path3), `.${Date.now()}.causal-edge-queue.tmp`);
+    writeFileSync26(tmp, JSON.stringify(queue), "utf8");
+    renameSync6(tmp, path3);
   } catch {
   }
 }
@@ -91243,8 +91814,8 @@ async function syncHistoryRevisionPage(opts) {
 init_src7();
 init_src();
 import { execFile as execFile6 } from "node:child_process";
-import { readFileSync as readFileSync36 } from "node:fs";
-import { join as join40 } from "node:path";
+import { readFileSync as readFileSync37 } from "node:fs";
+import { join as join41 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 
 // src/history-walk.ts
@@ -91796,7 +92367,7 @@ async function defaultGit(root, args2) {
 function readIgnoreLines(root, profile) {
   let lines = [];
   try {
-    lines = readFileSync36(join40(root, ".errataignore"), "utf8").split("\n");
+    lines = readFileSync37(join41(root, ".errataignore"), "utf8").split("\n");
   } catch {
   }
   return [...lines, ...profile.ignoreExtra ?? []].map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
@@ -92372,8 +92943,8 @@ async function startHistoryStage(root, input, client, walk11 = {}) {
 init_cloud_auth();
 import { createHash as createHash19 } from "node:crypto";
 import { execFileSync as execFileSync6 } from "node:child_process";
-import { existsSync as existsSync32, writeFileSync as writeFileSync26 } from "node:fs";
-import { join as join41 } from "node:path";
+import { existsSync as existsSync32, writeFileSync as writeFileSync27 } from "node:fs";
+import { join as join42 } from "node:path";
 
 // src/device-poll.ts
 var THROTTLED_POLL_MIN_WAIT_MS = 11e3;
@@ -92832,9 +93403,9 @@ function applyLinkDecision(root, profile, config2, decision, now = Date.now) {
   delete nextProfile.projectLinkHold;
   let wroteIgnore = false;
   if (decision.writeIgnoreStarter !== false) {
-    const target = join41(root, ".errataignore");
+    const target = join42(root, ".errataignore");
     if (!existsSync32(target)) {
-      writeFileSync26(target, IGNORE_STARTER, "utf8");
+      writeFileSync27(target, IGNORE_STARTER, "utf8");
       wroteIgnore = true;
     }
   }
@@ -92848,12 +93419,12 @@ init_registry();
 // src/adopt.ts
 init_git_remote();
 import { existsSync as existsSync33 } from "node:fs";
-import { dirname as dirname14, join as join42 } from "node:path";
+import { dirname as dirname15, join as join43 } from "node:path";
 function findGitRoot(absPath) {
   let dir = absPath;
   for (let depth = 0; depth < 64; depth++) {
-    if (existsSync33(join42(dir, ".git"))) return dir;
-    const parent = dirname14(dir);
+    if (existsSync33(join43(dir, ".git"))) return dir;
+    const parent = dirname15(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -93570,7 +94141,7 @@ async function startMultiDaemon(opts = {}) {
     records.push(rec);
     void ambientLinkAll();
     try {
-      writeFileSync27(
+      writeFileSync28(
         rec.engine.paths.daemonLock,
         daemonLockPayload({
           pid: process.pid,
@@ -93949,7 +94520,7 @@ async function startMultiDaemon(opts = {}) {
   baseUrl = `http://127.0.0.1:${port}`;
   try {
     ensureDir(globalDir());
-    writeFileSync27(
+    writeFileSync28(
       lockPath,
       daemonLockPayload({ pid: process.pid, webUiUrl: baseUrl, processStartedAt: PROCESS_STARTED_AT, entry: SELF_ENTRY, version: DAEMON_VERSION }),
       "utf8"
@@ -93958,7 +94529,7 @@ async function startMultiDaemon(opts = {}) {
   }
   for (const r of records) {
     try {
-      writeFileSync27(
+      writeFileSync28(
         r.engine.paths.daemonLock,
         daemonLockPayload({
           pid: process.pid,
@@ -94659,7 +95230,10 @@ async function startMultiDaemon(opts = {}) {
           projectId: project?.projectId,
           writeTarget: project ? null : receiptContext.context.default_write_target
         });
+        const parkPath = edgeParkPath(r.engine.paths.configDir, destinationKey);
+        const parkQueue = loadEdgePark(parkPath);
         const built = await buildInstanceBatch(r, {
+          edgeHolds: edgeHolds(parkQueue, Date.now()),
           destinationKey,
           profile: r.engine.profile,
           daemonVersion: DAEMON_VERSION,
@@ -94685,7 +95259,8 @@ async function startMultiDaemon(opts = {}) {
             // straddle rows where the counter is merely absent.
             blockedRepeat: 0,
             rejectedRepeat: 0,
-            edgesRejected: 0
+            edgesRejected: 0,
+            ...zeroEdgeSettleCounts(parkQueue)
           });
         }
         if (instances) {
@@ -94750,14 +95325,26 @@ async function startMultiDaemon(opts = {}) {
               if (typeof cloudId === "string" && cloudId) cloudIds.set(localId, cloudId);
             }
             const edgeReceipts = instanceEdgeReceipts(instances.edges, res.result.edges, cloudIds);
+            const echo = /* @__PURE__ */ new Map();
+            for (const node2 of res.result.nodes) {
+              if (node2.nodeId && node2.decision !== "rejected") echo.set(node2.canonicalId, node2.nodeId);
+            }
+            const settled = settleEdgeOutcomes(
+              parkQueue,
+              instances.edges,
+              matchEdgeVerdicts(instances.edges, res.result.edges, echo),
+              Date.now()
+            );
+            saveEdgePark(parkPath, settled.queue);
+            const edgeCounts = settled.counts;
             if (rejectedEdges.length > 0) {
               const byReason = /* @__PURE__ */ new Map();
               for (const re of rejectedEdges) {
-                const why = `${re.type}: ${re.reason ?? "no reason given"}`;
+                const why = `${re.type}: ${(re.reason ?? "no reason given").replace(/'[^']*'/g, "'\u2026'")}`;
                 byReason.set(why, (byReason.get(why) ?? 0) + 1);
               }
               console.warn(
-                `[sync\u2192cloud] [${projectName}] instances: ${rejectedEdges.length} edge(s) REJECTED by the door: ` + [...byReason.entries()].map(([why, n]) => `${n}\xD7 ${why}`).join(" | ")
+                `[sync\u2192cloud] [${projectName}] instances: ${rejectedEdges.length} edge(s) REJECTED by the door (parked ${edgeCounts.edgesParked}, re-parked ${edgeCounts.edgesReparked}, dropped ${edgeCounts.edgesDroppedRefused + edgeCounts.edgesDroppedExhausted + edgeCounts.edgesDroppedExpired}; park now ${edgeCounts.edgeParkSize}): ` + [...byReason.entries()].map(([why, n]) => `${n}\xD7 ${why}`).join(" | ")
               );
             }
             if (rejected.size > 0) {
@@ -94834,7 +95421,13 @@ async function startMultiDaemon(opts = {}) {
               });
             });
             let invalidatedReceipts = 0;
+            const affirmedThisDrain = new Set(echo.values());
+            let invalidationSkipped = 0;
             for (const failedId of invalidInstanceEndpointIds(res.result.edges)) {
+              if (affirmedThisDrain.has(failedId)) {
+                invalidationSkipped++;
+                continue;
+              }
               const localIds = new Set(instances.endpointSources[failedId] ?? []);
               for (const [wireId, cloudId] of cloudIds) if (cloudId === failedId) {
                 for (const id of instances.endpointSources[wireId] ?? [instances.contextNodeSources[wireId] ?? wireId]) localIds.add(id);
@@ -94861,7 +95454,9 @@ async function startMultiDaemon(opts = {}) {
               // failing every pass. Same total, different bug.
               blockedRepeat,
               rejectedRepeat,
-              edgesRejected: rejectedEdges.length
+              edgesRejected: rejectedEdges.length,
+              invalidationSkipped,
+              ...edgeCounts
             });
             return res.accepted;
           });
@@ -95453,7 +96048,7 @@ import { spawnSync as spawnSync2 } from "node:child_process";
 
 // src/codex-runtime.ts
 import { readdirSync as readdirSync13, statSync as statSync10 } from "node:fs";
-import { join as join43 } from "node:path";
+import { join as join44 } from "node:path";
 function resolveCodexExecutable(options = {}) {
   const platform = options.platform ?? process.platform;
   const env2 = options.env ?? process.env;
@@ -95468,13 +96063,13 @@ function resolveCodexExecutable(options = {}) {
   };
   for (const dir of (env2["PATH"] ?? env2["Path"] ?? "").split(";")) {
     if (!dir.trim()) continue;
-    const path3 = join43(dir.trim().replace(/^"|"$/g, ""), "codex.exe");
+    const path3 = join44(dir.trim().replace(/^"|"$/g, ""), "codex.exe");
     if (fileTime(path3) !== null) return path3;
   }
   if (!env2["LOCALAPPDATA"]) return "codex";
-  const root = join43(env2["LOCALAPPDATA"], "OpenAI", "Codex", "bin");
+  const root = join44(env2["LOCALAPPDATA"], "OpenAI", "Codex", "bin");
   try {
-    const candidates = readdirSync13(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join43(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) => join44(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";
@@ -95613,14 +96208,14 @@ async function diagnoseInstallation(cfg, dependencies) {
 
 // src/codex-doctor.ts
 import { spawn as spawn4 } from "node:child_process";
-import { readFileSync as readFileSync38, statSync as statSync11 } from "node:fs";
-import { join as join45 } from "node:path";
+import { readFileSync as readFileSync39, statSync as statSync11 } from "node:fs";
+import { join as join46 } from "node:path";
 import { createInterface } from "node:readline";
 
 // src/codex-hooks.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync9, readFileSync as readFileSync37, renameSync as renameSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync28 } from "node:fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync9, readFileSync as readFileSync38, renameSync as renameSync7, unlinkSync as unlinkSync5, writeFileSync as writeFileSync29 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { join as join44 } from "node:path";
+import { join as join45 } from "node:path";
 
 // src/hook-commands.ts
 function hookCurlCommand(port, path3 = "/api/hook") {
@@ -95824,34 +96419,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 (existsSync35(file2) && readFileSync37(file2, "utf8") === source) return;
+  if (existsSync35(file2) && readFileSync38(file2, "utf8") === source) return;
   const temp = `${file2}.${process.pid}.tmp`;
   try {
-    writeFileSync28(temp, source, { encoding: "utf8", mode: 384 });
-    renameSync6(temp, file2);
+    writeFileSync29(temp, source, { encoding: "utf8", mode: 384 });
+    renameSync7(temp, file2);
   } finally {
     if (existsSync35(temp)) unlinkSync5(temp);
   }
 }
 function refreshCodexRelay(root) {
-  const config2 = join44(root, ".codex", "config.toml");
+  const config2 = join45(root, ".codex", "config.toml");
   if (!existsSync35(config2)) return "absent";
-  const existing = readFileSync37(config2, "utf8");
+  const existing = readFileSync38(config2, "utf8");
   if (!existing.includes(CODEX_HOOKS_BEGIN) && !existing.includes(CODEX_HOOKS_END)) return "absent";
   replaceCodexHooks(existing, "");
-  const relay = join44(root, ".codex", "hooks", "errata-relay.mjs");
-  const prior = existsSync35(relay) ? readFileSync37(relay, "utf8") : "";
+  const relay = join45(root, ".codex", "hooks", "errata-relay.mjs");
+  const prior = existsSync35(relay) ? readFileSync38(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";
-  mkdirSync9(join44(root, ".codex", "hooks"), { recursive: true });
+  mkdirSync9(join45(root, ".codex", "hooks"), { recursive: true });
   writeRelay(relay, source);
   return "updated";
 }
-function hasCodexConfig(root, codexHome = process.env["CODEX_HOME"] || join44(homedir7(), ".codex")) {
-  return existsSync35(join44(root, ".codex")) || existsSync35(codexHome);
+function hasCodexConfig(root, codexHome = process.env["CODEX_HOME"] || join45(homedir7(), ".codex")) {
+  return existsSync35(join45(root, ".codex")) || existsSync35(codexHome);
 }
 function replaceCodexHooks(existing, block) {
   const begin = existing.indexOf(CODEX_HOOKS_BEGIN);
@@ -95867,14 +96462,14 @@ function replaceCodexHooks(existing, block) {
   return existing.trimEnd() + (existing.trim() ? "\n\n" : "") + block;
 }
 function writeCodexHooks(root, port, nodePath = process.execPath) {
-  const dir = join44(root, ".codex");
-  const file2 = join44(dir, "config.toml");
-  const relay = join44(dir, "hooks", "errata-relay.mjs");
+  const dir = join45(root, ".codex");
+  const file2 = join45(dir, "config.toml");
+  const relay = join45(dir, "hooks", "errata-relay.mjs");
   const block = buildCodexHooksToml(port, { nodePath, relayPath: relay });
-  const final = replaceCodexHooks(existsSync35(file2) ? readFileSync37(file2, "utf8") : "", block);
-  mkdirSync9(join44(dir, "hooks"), { recursive: true });
+  const final = replaceCodexHooks(existsSync35(file2) ? readFileSync38(file2, "utf8") : "", block);
+  mkdirSync9(join45(dir, "hooks"), { recursive: true });
   writeRelay(relay, buildCodexRelaySource(checkoutRootOf(root)));
-  if (!existsSync35(file2) || readFileSync37(file2, "utf8") !== final) writeFileSync28(file2, final, "utf8");
+  if (!existsSync35(file2) || readFileSync38(file2, "utf8") !== final) writeFileSync29(file2, final, "utf8");
   return file2;
 }
 
@@ -95883,7 +96478,7 @@ init_checkout_root();
 function inspectCodexRelay(cwd) {
   const root = nearestGitRoot(cwd) ?? cwd;
   try {
-    const source = readFileSync38(join45(root, ".codex", "hooks", "errata-relay.mjs"), "utf8");
+    const source = readFileSync39(join46(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" };
     }
@@ -95894,8 +96489,8 @@ function inspectCodexRelay(cwd) {
 function inspectCodexContext(cwd) {
   const root = checkoutRootOf(nearestGitRoot(cwd) ?? cwd);
   try {
-    const file2 = join45(root, ".errata", "context.md");
-    if (statSync11(file2).size <= 128 * 1024 && readFileSync38(file2, "utf8").trim()) {
+    const file2 = join46(root, ".errata", "context.md");
+    if (statSync11(file2).size <= 128 * 1024 && readFileSync39(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 {
@@ -96073,9 +96668,9 @@ function consolidationGapMs(lastPassMs, policy) {
 
 // src/codex-context-plugin.ts
 import { createHash as createHash20 } from "node:crypto";
-import { cpSync as cpSync2, existsSync as existsSync36, mkdirSync as mkdirSync10, readFileSync as readFileSync39, renameSync as renameSync7, writeFileSync as writeFileSync29 } from "node:fs";
+import { cpSync as cpSync2, existsSync as existsSync36, mkdirSync as mkdirSync10, readFileSync as readFileSync40, renameSync as renameSync8, writeFileSync as writeFileSync30 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { join as join46 } from "node:path";
+import { join as join47 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/error.js
@@ -96773,23 +97368,23 @@ 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 existsSync36(file2) ? readFileSync39(file2, "utf8") : "";
+  return existsSync36(file2) ? readFileSync40(file2, "utf8") : "";
 }
 function writeChanged(file2, content) {
   if (readText(file2) === content) return;
   const temp = `${file2}.${process.pid}.tmp`;
-  writeFileSync29(temp, content, "utf8");
-  renameSync7(temp, file2);
+  writeFileSync30(temp, content, "utf8");
+  renameSync8(temp, file2);
 }
 function bundledContextPlugin() {
   const packaged = fileURLToPath2(new URL("./resources/context-plugin/", import.meta.url));
-  if (existsSync36(join46(packaged, ".codex-plugin/plugin.json"))) return packaged;
+  if (existsSync36(join47(packaged, ".codex-plugin/plugin.json"))) return packaged;
   return fileURLToPath2(new URL("../dist/resources/context-plugin/", import.meta.url));
 }
 function refreshCodexContextPlugin(root) {
-  const file2 = join46(root, ".agents", "plugins", "marketplace.json");
+  const file2 = join47(root, ".agents", "plugins", "marketplace.json");
   if (!existsSync36(file2)) return false;
-  const marketplace = JSON.parse(readFileSync39(file2, "utf8"));
+  const marketplace = JSON.parse(readFileSync40(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;
@@ -96800,24 +97395,24 @@ function refreshCodexContextPlugin(root) {
 function installCodexContextPlugin(root, options = {}) {
   const bundle = options.bundle ?? bundledContextPlugin();
   const manifest = JSON.parse(
-    readFileSync39(join46(bundle, ".codex-plugin/plugin.json"), "utf8")
+    readFileSync40(join47(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 = readFileSync39(join46(bundle, "SHA256SUMS"), "utf8");
+  const checksums = readFileSync40(join47(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 = createHash20("sha256").update(readFileSync39(join46(bundle, match2[2]))).digest("hex");
+    const actual = createHash20("sha256").update(readFileSync40(join47(bundle, match2[2]))).digest("hex");
     if (actual !== match2[1])
       throw new Error(`Bundled Errata Context checksum mismatch: ${match2[2]}`);
   }
   const release = `${manifest.version}-${createHash20("sha256").update(checksums).digest("hex").slice(0, 12)}`;
-  const plugin = join46(root, ".errata", "plugins", NAME, release);
-  const marketplaceFile = join46(root, ".agents", "plugins", "marketplace.json");
+  const plugin = join47(root, ".errata", "plugins", NAME, release);
+  const marketplaceFile = join47(root, ".agents", "plugins", "marketplace.json");
   const priorMarketplace = readText(marketplaceFile);
   const marketplace = priorMarketplace ? JSON.parse(priorMarketplace) : {
     name: "errata-local",
@@ -96838,12 +97433,12 @@ function installCodexContextPlugin(root, options = {}) {
     );
   }
   const key = `${NAME}@${marketplace.name}`;
-  const configFile = join46(root, ".codex", "config.toml");
+  const configFile = join47(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"] ?? join46(homedir8(), ".codex");
-  const globalPlugins = object2(parse4(readText(join46(codexHome, "config.toml"))).plugins);
+  const codexHome = options.codexHome ?? process.env["CODEX_HOME"] ?? join47(homedir8(), ".codex");
+  const globalPlugins = object2(parse4(readText(join47(codexHome, "config.toml"))).plugins);
   const disabledGlobally = Object.entries(globalPlugins).some(
     ([name2, value]) => (name2 === NAME || name2.startsWith(`${NAME}@`)) && object2(value).enabled === false
   );
@@ -96867,13 +97462,13 @@ enabled = ${enabled}
   mkdirSync10(plugin, { recursive: true });
   cpSync2(bundle, plugin, { recursive: true });
   writeChanged(
-    join46(plugin, ".mcp.json"),
+    join47(plugin, ".mcp.json"),
     JSON.stringify(
       {
         mcpServers: {
           errata_context: {
             command: options.nodePath ?? process.execPath,
-            args: [join46(plugin, "dist", "mcp-server.mjs")],
+            args: [join47(plugin, "dist", "mcp-server.mjs")],
             env: { ERRATA_WORKSPACE: root, ERRATA_CONTEXT_VERSION: manifest.version }
           }
         }
@@ -96882,8 +97477,8 @@ enabled = ${enabled}
       2
     ) + "\n"
   );
-  mkdirSync10(join46(root, ".agents", "plugins"), { recursive: true });
-  mkdirSync10(join46(root, ".codex"), { recursive: true });
+  mkdirSync10(join47(root, ".agents", "plugins"), { recursive: true });
+  mkdirSync10(join47(root, ".codex"), { recursive: true });
   writeChanged(marketplaceFile, JSON.stringify(marketplace, null, 2) + "\n");
   writeChanged(configFile, nextConfig);
   return { plugin, enabled, marketplace: marketplaceFile };
@@ -96891,15 +97486,15 @@ enabled = ${enabled}
 
 // src/codex-hook-refresh.ts
 init_checkout_root();
-import { existsSync as existsSync37, readdirSync as readdirSync14, readFileSync as readFileSync40 } from "node:fs";
-import { dirname as dirname15, join as join47, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync37, readdirSync as readdirSync14, readFileSync as readFileSync41 } from "node:fs";
+import { dirname as dirname16, join as join48, resolve as resolve8 } from "node:path";
 init_registry();
 function codexHookRoots(roots) {
   const found = new Set(roots.map((root) => resolve8(root)));
   for (const root of [...found]) {
     const main2 = mainCheckoutOfWorktree(root) ?? root;
     found.add(main2);
-    const dir = join47(main2, ".git", "worktrees");
+    const dir = join48(main2, ".git", "worktrees");
     if (!existsSync37(dir)) continue;
     let names;
     try {
@@ -96909,7 +97504,7 @@ function codexHookRoots(roots) {
     }
     for (const name2 of names) {
       try {
-        const checkout = dirname15(readFileSync40(join47(dir, name2, "gitdir"), "utf8").trim());
+        const checkout = dirname16(readFileSync41(join48(dir, name2, "gitdir"), "utf8").trim());
         if (mainCheckoutOfWorktree(checkout) === main2) found.add(checkout);
       } catch {
       }
@@ -96931,9 +97526,9 @@ function refreshInstalledCodexRelays(roots = listWorkspaceEntries().map((entry)
 }
 
 // src/claude-statusline.ts
-import { existsSync as existsSync38, mkdirSync as mkdirSync11, readFileSync as readFileSync41, writeFileSync as writeFileSync30 } from "node:fs";
+import { existsSync as existsSync38, mkdirSync as mkdirSync11, readFileSync as readFileSync42, writeFileSync as writeFileSync31 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
-import { dirname as dirname16, join as join48 } from "node:path";
+import { dirname as dirname17, join as join49 } from "node:path";
 var STATUSLINE_RELAY_SOURCE = String.raw`// errata-managed: regenerated by errata init / install-hooks claude
 import { readFileSync } from 'node:fs';
 
@@ -96981,8 +97576,8 @@ function isSameInstall(value, relay) {
   return command.includes(relay.replace(/\\/g, "/").toLowerCase());
 }
 function userClaudeSettingsPath() {
-  const base = process.env["CLAUDE_CONFIG_DIR"] ?? join48(homedir9(), ".claude");
-  return join48(base, "settings.json");
+  const base = process.env["CLAUDE_CONFIG_DIR"] ?? join49(homedir9(), ".claude");
+  return join49(base, "settings.json");
 }
 function ensureUserStatusLine(opts) {
   const env2 = opts.env ?? process.env;
@@ -96992,21 +97587,21 @@ function ensureUserStatusLine(opts) {
   let settings = {};
   if (existsSync38(settingsPath)) {
     try {
-      const parsed = JSON.parse(readFileSync41(settingsPath, "utf8"));
+      const parsed = JSON.parse(readFileSync42(settingsPath, "utf8"));
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return "unreadable";
       settings = parsed;
     } catch {
       return "unreadable";
     }
   }
-  const relay = join48(opts.relayDir, STATUSLINE_RELAY_FILE);
+  const relay = join49(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";
   mkdirSync11(opts.relayDir, { recursive: true });
-  if (!existsSync38(relay) || readFileSync41(relay, "utf8") !== STATUSLINE_RELAY_SOURCE) {
-    writeFileSync30(relay, STATUSLINE_RELAY_SOURCE, "utf8");
+  if (!existsSync38(relay) || readFileSync42(relay, "utf8") !== STATUSLINE_RELAY_SOURCE) {
+    writeFileSync31(relay, STATUSLINE_RELAY_SOURCE, "utf8");
   }
   const nodePath = opts.nodePath ?? process.execPath;
   const next = {
@@ -97017,8 +97612,8 @@ function ensureUserStatusLine(opts) {
     return ownMain ? "kept-own" : "unchanged";
   }
   Object.assign(settings, next);
-  mkdirSync11(dirname16(settingsPath), { recursive: true });
-  writeFileSync30(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  mkdirSync11(dirname17(settingsPath), { recursive: true });
+  writeFileSync31(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
   return "installed";
 }
 function describeStatusLineOutcome(outcome) {
@@ -97038,8 +97633,8 @@ function describeStatusLineOutcome(outcome) {
 
 // src/claude-mods.ts
 import { createHash as createHash21 } from "node:crypto";
-import { cpSync as cpSync3, existsSync as existsSync39, mkdirSync as mkdirSync12, readFileSync as readFileSync42, readdirSync as readdirSync15, rmSync as rmSync4, statSync as statSync12, writeFileSync as writeFileSync31 } from "node:fs";
-import { delimiter as delimiter2, dirname as dirname17, join as join49, relative as relative8, resolve as resolve9, sep as sep5 } from "node:path";
+import { cpSync as cpSync3, existsSync as existsSync39, mkdirSync as mkdirSync12, readFileSync as readFileSync43, readdirSync as readdirSync15, rmSync as rmSync4, statSync as statSync12, writeFileSync as writeFileSync32 } from "node:fs";
+import { delimiter as delimiter2, dirname as dirname18, join as join50, relative as relative8, resolve as resolve9, sep as sep5 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var CLAUDE_PLUGIN_DIRS_ENV = "CLAUDE_CODE_PLUGIN_DIRS";
 var HASH_FILE = ".errata-mod-hash";
@@ -97054,7 +97649,7 @@ function isEngineOwned(relPath) {
 function listFiles(root, dir = root) {
   const out2 = [];
   for (const name2 of readdirSync15(dir)) {
-    const abs = join49(dir, name2);
+    const abs = join50(dir, name2);
     if (isEngineOwned(relative8(root, abs))) continue;
     if (statSync12(abs).isDirectory()) out2.push(...listFiles(root, abs));
     else out2.push(abs);
@@ -97066,14 +97661,14 @@ function modHash(dir) {
   for (const abs of listFiles(dir).sort()) {
     h.update(relative8(dir, abs).split(sep5).join("/"));
     h.update("\0");
-    h.update(readFileSync42(abs));
+    h.update(readFileSync43(abs));
     h.update("\0");
   }
   return h.digest("hex");
 }
 function bundledMods(bundleDir) {
   if (!existsSync39(bundleDir)) return [];
-  return readdirSync15(bundleDir).filter((name2) => existsSync39(join49(bundleDir, name2, ".claude-plugin", "plugin.json")));
+  return readdirSync15(bundleDir).filter((name2) => existsSync39(join50(bundleDir, name2, ".claude-plugin", "plugin.json")));
 }
 function sameDir(a, b) {
   const norm = (p) => resolve9(p).replace(/[\\/]+$/, "").toLowerCase();
@@ -97090,7 +97685,7 @@ function off(env2) {
 function readSettings(path3) {
   if (!existsSync39(path3)) return {};
   try {
-    const parsed = JSON.parse(readFileSync42(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync43(path3, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
     return parsed;
   } catch {
@@ -97114,13 +97709,13 @@ function currentDirs(settings) {
   return raw2.split(delimiter2).map((s) => s.trim()).filter(Boolean);
 }
 function writeSettings(path3, settings) {
-  mkdirSync12(dirname17(path3), { recursive: true });
-  writeFileSync31(path3, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  mkdirSync12(dirname18(path3), { recursive: true });
+  writeFileSync32(path3, JSON.stringify(settings, null, 2) + "\n", "utf8");
 }
 function ensureClaudeMods(opts) {
   const env2 = opts.env ?? process.env;
   const settingsPath = opts.userSettingsPath ?? userClaudeSettingsPath();
-  const modsRoot = join49(opts.installRoot, "claude-mods");
+  const modsRoot = join50(opts.installRoot, "claude-mods");
   if (off(env2)) {
     const settings2 = readSettings(settingsPath);
     if (!settings2) return { kind: "unreadable" };
@@ -97137,14 +97732,14 @@ function ensureClaudeMods(opts) {
   let changed = false;
   const installed = [];
   for (const name2 of names) {
-    const src = join49(bundleDir, name2);
-    const dest = join49(modsRoot, name2);
+    const src = join50(bundleDir, name2);
+    const dest = join50(modsRoot, name2);
     const hash2 = modHash(src);
-    const hashFile = join49(dest, HASH_FILE);
-    if (!existsSync39(hashFile) || readFileSync42(hashFile, "utf8") !== hash2) {
+    const hashFile = join50(dest, HASH_FILE);
+    if (!existsSync39(hashFile) || readFileSync43(hashFile, "utf8") !== hash2) {
       rmSync4(dest, { recursive: true, force: true });
       cpSync3(src, dest, { recursive: true, filter: (p) => !isEngineOwned(relative8(src, p)) });
-      writeFileSync31(hashFile, hash2, "utf8");
+      writeFileSync32(hashFile, hash2, "utf8");
       changed = true;
     }
     installed.push(dest);
@@ -97565,9 +98160,9 @@ function resolveHookPort(explicit) {
       }
     }
   }
-  const settingsPath = join50(ROOT, ".claude", "settings.json");
+  const settingsPath = join51(ROOT, ".claude", "settings.json");
   try {
-    if (existsSync40(settingsPath)) return installedHookPort(readFileSync43(settingsPath, "utf8")) ?? 7891;
+    if (existsSync40(settingsPath)) return installedHookPort(readFileSync44(settingsPath, "utf8")) ?? 7891;
   } catch {
   }
   return 7891;
@@ -97593,13 +98188,13 @@ async function cmdInit() {
     console.log("");
     console.log("installing harness hooks...");
     const { existsSync: existsSync41 } = await import("node:fs");
-    const { join: join51 } = await import("node:path");
+    const { join: join52 } = 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 (existsSync41(join51(ROOT, ".cursor"))) {
+    if (existsSync41(join52(ROOT, ".cursor"))) {
       try {
         await installCursorMcpConfig();
       } catch (err2) {
@@ -98821,7 +99416,7 @@ async function cmdReview() {
     console.log("(review queue empty)");
     return;
   }
-  const queue = JSON.parse(readFileSync43(paths.reviewQueue, "utf8"));
+  const queue = JSON.parse(readFileSync44(paths.reviewQueue, "utf8"));
   if (queue.length === 0) {
     console.log("(review queue empty)");
     return;
@@ -99560,7 +100155,7 @@ async function gatherReportData(generatedAt) {
   };
 }
 async function cmdReport(args2) {
-  const { mkdirSync: mkdirSync13, writeFileSync: writeFileSync32 } = await import("node:fs");
+  const { mkdirSync: mkdirSync13, writeFileSync: writeFileSync33 } = 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();
@@ -99573,8 +100168,8 @@ async function cmdReport(args2) {
   const outDir = workspacePaths(ROOT).configDir;
   mkdirSync13(outDir, { recursive: true });
   const files = renderReport2(data, { includeFutureVerbs });
-  for (const f of files) writeFileSync32(join50(outDir, f.name), f.html, "utf8");
-  const indexPath = join50(outDir, "report.html");
+  for (const f of files) writeFileSync33(join51(outDir, f.name), f.html, "utf8");
+  const indexPath = join51(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`
@@ -99630,7 +100225,7 @@ function spawnDaemonDetached(options = {}) {
   try {
     const logPath = daemonLogPath();
     try {
-      if (statSync13(logPath).size > 5 * 1024 * 1024) renameSync8(logPath, `${logPath}.1`);
+      if (statSync13(logPath).size > 5 * 1024 * 1024) renameSync9(logPath, `${logPath}.1`);
     } catch {
     }
     out2 = openSync3(logPath, "a");
@@ -99699,24 +100294,24 @@ async function cmdInstallHooks(args2) {
   }
 }
 async function installOpencodePlugin(port) {
-  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync44, writeFileSync: writeFileSync32 } = await import("node:fs");
-  const { join: join51 } = await import("node:path");
-  const dir = join51(ROOT, ".opencode", "plugin");
+  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync45, writeFileSync: writeFileSync33 } = await import("node:fs");
+  const { join: join52 } = await import("node:path");
+  const dir = join52(ROOT, ".opencode", "plugin");
   if (!existsSync41(dir)) mkdirSync13(dir, { recursive: true });
-  const file2 = join51(dir, "inerrata.js");
+  const file2 = join52(dir, "inerrata.js");
   if (existsSync41(file2)) {
-    const head2 = readFileSync44(file2, "utf8").split("\n")[0] ?? "";
+    const head2 = readFileSync45(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);
     }
   }
-  writeFileSync32(file2, buildOpencodePluginSource(port, { version: DAEMON_VERSION }), "utf8");
-  const cfgFile = join51(ROOT, "opencode.json");
+  writeFileSync33(file2, buildOpencodePluginSource(port, { version: DAEMON_VERSION }), "utf8");
+  const cfgFile = join52(ROOT, "opencode.json");
   let cfg = { $schema: "https://opencode.ai/config.json" };
   if (existsSync41(cfgFile)) {
     try {
-      cfg = JSON.parse(readFileSync44(cfgFile, "utf8"));
+      cfg = JSON.parse(readFileSync45(cfgFile, "utf8"));
     } catch {
       console.error(`refusing to touch invalid JSON at ${cfgFile} \u2014 fix it and re-run`);
       process.exit(2);
@@ -99727,7 +100322,7 @@ async function installOpencodePlugin(port) {
   if (!hadErrata) {
     const inv = errataMcpInvocation();
     cfg.mcp["errata"] = { type: "local", command: [inv.command, ...inv.args] };
-    writeFileSync32(cfgFile, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+    writeFileSync33(cfgFile, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   }
   console.log(`installed OpenCode plugin \u2192 ${file2}`);
   if (hadErrata) console.log(`  mcp.errata already present in ${cfgFile} \u2014 left untouched`);
@@ -99762,15 +100357,15 @@ function installClaudeMods() {
   }
 }
 async function installClaudeHooks(port) {
-  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync44, writeFileSync: writeFileSync32 } = await import("node:fs");
-  const { join: join51 } = await import("node:path");
-  const dir = join51(ROOT, ".claude");
+  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync45, writeFileSync: writeFileSync33 } = await import("node:fs");
+  const { join: join52 } = await import("node:path");
+  const dir = join52(ROOT, ".claude");
   if (!existsSync41(dir)) mkdirSync13(dir, { recursive: true });
-  const file2 = join51(dir, "settings.json");
+  const file2 = join52(dir, "settings.json");
   let settings = {};
   if (existsSync41(file2)) {
     try {
-      settings = JSON.parse(readFileSync44(file2, "utf8"));
+      settings = JSON.parse(readFileSync45(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -99819,12 +100414,12 @@ async function installClaudeHooks(port) {
     list.push({ hooks: [{ type: "command", command: injectCmd }] });
   }
   removeProjectStatusLine(settings);
-  writeFileSync32(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  writeFileSync33(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
   console.log(`installed Claude Code hooks \u2192 ${file2}`);
   console.log(`  ${ensureStatusLine(port)}`);
   console.log(`  ${installClaudeMods().line}`);
   await installClaudeMcpConfig();
-  const claudeMd = join51(ROOT, "CLAUDE.md");
+  const claudeMd = join52(ROOT, "CLAUDE.md");
   const recall = writeManagedBlock(claudeMd, { body: RECALL_FIRST_BLOCK });
   if (recall.kind === "collision") {
     console.warn(
@@ -99836,15 +100431,15 @@ async function installClaudeHooks(port) {
   console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
 }
 async function installClaudeMcpConfig() {
-  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync44, writeFileSync: writeFileSync32 } = await import("node:fs");
-  const { join: join51, dirname: dirname18 } = await import("node:path");
-  const file2 = join51(ROOT, ".mcp.json");
-  const dir = dirname18(file2);
+  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync45, writeFileSync: writeFileSync33 } = await import("node:fs");
+  const { join: join52, dirname: dirname19 } = await import("node:path");
+  const file2 = join52(ROOT, ".mcp.json");
+  const dir = dirname19(file2);
   if (!existsSync41(dir)) mkdirSync13(dir, { recursive: true });
   let cfg = {};
   if (existsSync41(file2)) {
     try {
-      cfg = JSON.parse(readFileSync44(file2, "utf8"));
+      cfg = JSON.parse(readFileSync45(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -99852,21 +100447,21 @@ async function installClaudeMcpConfig() {
   }
   cfg.mcpServers ??= {};
   cfg.mcpServers["errata"] = errataMcpInvocation();
-  writeFileSync32(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  writeFileSync33(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: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync44, writeFileSync: writeFileSync32 } = await import("node:fs");
-  const { join: join51 } = await import("node:path");
-  const dir = join51(ROOT, ".cursor");
+  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync45, writeFileSync: writeFileSync33 } = await import("node:fs");
+  const { join: join52 } = await import("node:path");
+  const dir = join52(ROOT, ".cursor");
   if (!existsSync41(dir)) mkdirSync13(dir, { recursive: true });
-  const file2 = join51(dir, "mcp.json");
+  const file2 = join52(dir, "mcp.json");
   let cfg = {};
   if (existsSync41(file2)) {
     try {
-      cfg = JSON.parse(readFileSync44(file2, "utf8"));
+      cfg = JSON.parse(readFileSync45(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -99874,7 +100469,7 @@ async function installCursorMcpConfig() {
   }
   cfg.mcpServers ??= {};
   cfg.mcpServers["errata"] = errataMcpInvocation();
-  writeFileSync32(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  writeFileSync33(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`);
@@ -99885,7 +100480,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(join50(hookRoot, "AGENTS.md"), {
+  const instructions = writeManagedBlock(join51(hookRoot, "AGENTS.md"), {
     body: AGENTS_POINTER_BODY,
     stable: true
   });
@@ -100331,9 +100926,9 @@ async function cmdDash(args2) {
       await yieldToLoop2();
       try {
         const items = selectDurableMemory(handle2.sharedStore, r.engine.profile, {
-          atCommit: readGitRefState(join50(r.root, ".git")).sha ?? void 0
+          atCommit: readGitRefState(join51(r.root, ".git")).sha ?? void 0
         });
-        const res = bleedRules(join50(r.root, ".claude", "rules"), items);
+        const res = bleedRules(join51(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` : "")