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

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 };
     }
@@ -26850,8 +27034,10 @@ __export(src_exports2, {
   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 +27079,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,
@@ -26928,6 +27118,7 @@ __export(src_exports2, {
   induceTriage: () => induceTriage,
   ingestDesignProblem: () => ingestDesignProblem,
   ingestWitnessedVulnerability: () => ingestWitnessedVulnerability,
+  installLineageIntegrityRepair: () => installLineageIntegrityRepair,
   isConstraintProblem: () => isConstraintProblem,
   isFragmentFixNote: () => isFragmentFixNote,
   isPlaceholderStatement: () => isPlaceholderStatement,
@@ -26983,7 +27174,9 @@ __export(src_exports2, {
   reinforceSameAnchorProblem: () => reinforceSameAnchorProblem,
   relateClaims: () => relateClaims,
   reopenAutoClosedProblems: () => reopenAutoClosedProblems,
+  reopenCascadeClosedEdges: () => reopenCascadeClosedEdges,
   repairLegacyAnchorsFromStatement: () => repairLegacyAnchorsFromStatement,
+  repairLineageIntegrity: () => repairLineageIntegrity,
   resolveDesignProblemById: () => resolveDesignProblemById,
   resolveDesignProblemByStatement: () => resolveDesignProblemByStatement,
   resolveEnclosingSymbol: () => resolveEnclosingSymbol,
@@ -27033,6 +27226,7 @@ var init_src5 = __esm({
     init_tools();
     init_principle_sync();
     init_mechanism_liveness();
+    init_lineage_integrity();
     init_wm_calibration();
   }
 });
@@ -33296,7 +33490,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 +38182,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 +38275,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 +44368,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 +47969,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 +47982,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 +48645,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}
@@ -81472,15 +81679,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 +81708,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 +81718,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 +81736,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 +86043,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.4180" : "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;