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

package/pass-worker.mjs

@@ -16402,20 +16402,20 @@ function openDatabase(path2, 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;
     }
   });
@@ -17609,9 +17609,11 @@ async function incrementalReindex(store2, rootPath, workspaceId, changedAbsPaths
       signatureAfter: a.signature
     });
   }
+  const repointable = /* @__PURE__ */ new Map();
   store2.transaction(() => {
     for (const nid of changedIds) store2.freezeNode(nid, t);
     for (const nid of removedIds) {
+      repointable.set(nid, store2.inEdges(nid, ["CALLS", "ACCESSES", "ANCHORED_AT"]));
       for (const e of store2.outEdges(nid)) store2.closeEdge(e.id, t);
       store2.closeNode(nid, t);
     }
@@ -17700,8 +17702,8 @@ async function incrementalReindex(store2, rootPath, workspaceId, changedAbsPaths
             version: b.version + 1
           });
           store2.mergeEdge(continuesEdge(m, t));
-          for (const e of store2.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 || !store2.liveNodeIds([e.from]).has(e.from)) continue;
             const newId = edgeId(e.from, e.type, m.toNid);
             if (!store2.getEdge(newId)) {
               store2.mergeEdge({ ...e, id: newId, to: m.toNid, lastSeenAt: t });
@@ -23793,10 +23795,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;
@@ -26091,6 +26093,169 @@ function textIndexReady(db) {
   return db.prepare("SELECT value FROM store_meta WHERE key = ?").get(TEXT_INDEX_KEY)?.["value"] === "installed";
 }
 
+// ../../packages/local-graph/src/lineage-integrity.ts
+var statements = /* @__PURE__ */ new WeakMap();
+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;
+}
+var HISTORY_EDGE_TYPES = [
+  "SUPERSEDED_BY",
+  "CONTINUES",
+  "FORKED_FROM",
+  "REGRESSION_OF",
+  "SPLIT_INTO",
+  "REVEALED_BY"
+];
+var LINEAGE_INTEGRITY_KEY = "lineage-integrity-v1";
+var HISTORY_SQL = HISTORY_EDGE_TYPES.map((t) => `'${t}'`).join(",");
+var NOT_HISTORY = `type NOT IN (${HISTORY_SQL})`;
+var NOT_HISTORICAL_ROW = `json_type(attrs_json, '$.historical') IS NOT 'true'`;
+var 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'))`;
+var PRESENT = (n) => `(${n}.valid_to IS NULL OR ${RETAINS_EDGES(n)})`;
+var 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")}))`;
+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;
+  });
+}
+
 // ../../packages/math/src/pagerank.ts
 function pagerank(input) {
   const damping = input.damping ?? 0.85;
@@ -26973,6 +27138,7 @@ var SqliteGraphStore = class {
         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 (
@@ -27183,6 +27349,12 @@ var SqliteGraphStore = class {
         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");
@@ -27351,15 +27523,15 @@ var SqliteGraphStore = class {
   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 cacheKey = attrKeys.join(",");
-    let stmt = this.fieldStmts.get(cacheKey);
-    if (!stmt) {
+    let stmt2 = this.fieldStmts.get(cacheKey);
+    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(cacheKey, stmt);
+      this.fieldStmts.set(cacheKey, 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}`]);
@@ -27479,14 +27651,14 @@ var SqliteGraphStore = class {
   }
   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;
   }
@@ -27685,12 +27857,12 @@ var SqliteGraphStore = class {
     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) {
@@ -27891,22 +28063,28 @@ var SqliteGraphStore = class {
     }
   }
   reviveReobserved(relPaths, workspaceId, since) {
-    let revived = 0;
+    const revived = [];
     const CHUNK = 400;
     for (let i2 = 0; i2 < relPaths.length; i2 += CHUNK) {
       const slice = relPaths.slice(i2, i2 + CHUNK);
       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, workspaceId, ...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, workspaceId, ...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 };
@@ -28052,8 +28230,9 @@ var SqliteGraphStore = class {
     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 });
@@ -29588,6 +29767,28 @@ var MECHANISMS = [
     // 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",
@@ -29642,12 +29843,31 @@ var MECHANISMS = [
     // 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",

package/resources/context-plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "errata-context",
-  "version": "2.0.22-dev.4173",
+  "version": "2.0.22-dev.4186",
   "description": "A minimal 3D view of loaded Errata priors and recent graph bursts.",
   "author": {
     "name": "inErrata"

package/resources/context-plugin/SHA256SUMS

@@ -1,4 +1,4 @@
-43b3c654071e6c4abeaa0d49cc279d846fec01d0d38972ac2df4a1617076f727  .codex-plugin/plugin.json
+0c3dd7adb669771f96dc8641fcdb302bb1d5441252d072f8b4cd9e3c947ab6c8  .codex-plugin/plugin.json
 a7bebae9fb01c838d6c75fc784129e28be571233fa66ff5ee8039b574f35ccf7  assets/icon.png
 fc38b64e4df1e0b72c35764bef6c4c05430d97c9009ad0ecc8a9e75b4deab232  configure-local.mjs
 73dc6028b3b070257c7c31f252d11e55a9e096f4aed0f187f10cb21716e1e6d7  dist/client.js