@inerrata-corporation/errata 2.0.2-dev.650 → 2.0.2-dev.682

package/consolidate-worker.mjs

@@ -15579,6 +15579,7 @@ function openDatabase(path) {
       db.exec("PRAGMA journal_mode = WAL");
       db.exec("PRAGMA synchronous = NORMAL");
       db.exec("PRAGMA busy_timeout = 5000");
+      db.exec("PRAGMA journal_size_limit = 67108864");
     } catch {
     }
   }
@@ -16562,6 +16563,96 @@ var SqliteGraphStore = class {
     const rows = this.db.prepare("SELECT from_id, to_id, type FROM edges WHERE valid_to IS NULL").all();
     return rows.map((r) => ({ from: r.from_id, to: r.to_id, type: r.type }));
   }
+  getMeta(key) {
+    const r = this.db.prepare("SELECT value FROM store_meta WHERE key = ?").get(key);
+    return r?.value ?? null;
+  }
+  setMeta(key, value) {
+    this.db.prepare(
+      "INSERT INTO store_meta (key, value) VALUES (:key, :value) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+    ).run({ key, value });
+  }
+  dirtyNodeIdsSince(ts) {
+    const rows = this.db.prepare("SELECT id FROM nodes WHERE valid_to IS NULL AND last_updated_at > ?").all(ts);
+    return rows.map((r) => r.id);
+  }
+  /** Endpoints of edges TOUCHED since `ts` — created, re-seen, or CLOSED.
+   *  Closures matter as much as additions: a node that lost inflow is rank-dirty
+   *  while its own row never updated, so removal endpoints must seed the
+   *  incremental region or the stale inflow persists until the full backstop. */
+  edgeEndpointsTouchedSince(ts) {
+    const rows = this.db.prepare(
+      `SELECT from_id, to_id FROM edges
+         WHERE (valid_to IS NULL AND (created_at > :ts OR last_seen_at > :ts))
+            OR (valid_to IS NOT NULL AND valid_to > :ts)`
+    ).all({ ts });
+    return rows.map((r) => ({ from: r.from_id, to: r.to_id }));
+  }
+  /** Lightweight out-edges for a SET of sources, chunked IN-lists — the region
+   *  assembly path for incremental PageRank (per-node outEdges() at region
+   *  scale re-creates the 106k-prepared-calls problem the batch scan solved). */
+  outEdgesForMany(ids) {
+    return this.edgesForMany(ids, "from_id");
+  }
+  inEdgesForMany(ids) {
+    return this.edgesForMany(ids, "to_id");
+  }
+  /** Stored pageRank for a SET of ids (live rows only — a closed id is simply
+   *  absent, which is how incremental region assembly drops dead endpoints). */
+  ranksForMany(ids) {
+    const out = /* @__PURE__ */ new Map();
+    const CHUNK = 400;
+    for (let i = 0; i < ids.length; i += CHUNK) {
+      const chunk = ids.slice(i, i + CHUNK);
+      const placeholders = chunk.map(() => "?").join(", ");
+      const rows = this.db.prepare(
+        `SELECT id, page_rank FROM nodes WHERE id IN (${placeholders}) AND valid_to IS NULL`
+      ).all(...chunk);
+      for (const r of rows) out.set(r.id, r.page_rank);
+    }
+    return out;
+  }
+  /** The minimal row set the landmark sweep needs — landmark CANDIDATES
+   *  (Pattern/RootCause), everything currently flagged, and every
+   *  persistent-tier node (force-landmarks). A few thousand rows, so the
+   *  incremental path can refresh the GLOBAL landmark set without the 179k-row
+   *  scanLiveNodes materialization. */
+  landmarkSweepRows() {
+    const rows = this.db.prepare(
+      `SELECT id, label, page_rank, is_landmark, memory_tier, extraction_source FROM nodes
+         WHERE valid_to IS NULL
+           AND (memory_tier = 'persistent' OR is_landmark = 1 OR label IN ('Pattern', 'RootCause'))`
+    ).all();
+    return rows.map((r) => ({
+      id: r.id,
+      label: r.label,
+      pageRank: r.page_rank,
+      isLandmark: r.is_landmark === 1,
+      memoryTier: r.memory_tier,
+      extractionSource: r.extraction_source
+    }));
+  }
+  edgesForMany(ids, col) {
+    const out = [];
+    const CHUNK = 400;
+    for (let i = 0; i < ids.length; i += CHUNK) {
+      const chunk = ids.slice(i, i + CHUNK);
+      const placeholders = chunk.map(() => "?").join(", ");
+      const rows = this.db.prepare(
+        `SELECT from_id, to_id, type FROM edges WHERE ${col} IN (${placeholders}) AND valid_to IS NULL`
+      ).all(...chunk);
+      for (const r of rows) out.push({ from: r.from_id, to: r.to_id, type: r.type });
+    }
+    return out;
+  }
+  checkpointWal() {
+    try {
+      const r = this.db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+      return r ?? null;
+    } catch {
+      return null;
+    }
+  }
   reviveReobserved(relPaths, workspaceId, since) {
     let revived = 0;
     const CHUNK = 400;

package/errata.mjs

@@ -305,6 +305,10 @@ var init_castalia = __esm({
       // git topology, not signal-flow
       "AUTHORED_BY",
       // git authorship, not signal-flow
+      "PRODUCED",
+      // edit-episode provenance (Episode→symbol), not signal-flow — the family
+      // above was excluded together but this member slipped the net (LC-produced-pagerank);
+      // at 43% of all live edges it was the largest single edge population flowing rank
       "CONTRIBUTED",
       // agent attribution (Agent → knowledge), not signal-flow
       "SUPERSEDES",
@@ -16399,6 +16403,7 @@ function openDatabase(path2) {
       db.exec("PRAGMA journal_mode = WAL");
       db.exec("PRAGMA synchronous = NORMAL");
       db.exec("PRAGMA busy_timeout = 5000");
+      db.exec("PRAGMA journal_size_limit = 67108864");
     } catch {
     }
   }
@@ -17237,6 +17242,96 @@ CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.re
         const rows = this.db.prepare("SELECT from_id, to_id, type FROM edges WHERE valid_to IS NULL").all();
         return rows.map((r) => ({ from: r.from_id, to: r.to_id, type: r.type }));
       }
+      getMeta(key) {
+        const r = this.db.prepare("SELECT value FROM store_meta WHERE key = ?").get(key);
+        return r?.value ?? null;
+      }
+      setMeta(key, value) {
+        this.db.prepare(
+          "INSERT INTO store_meta (key, value) VALUES (:key, :value) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+        ).run({ key, value });
+      }
+      dirtyNodeIdsSince(ts) {
+        const rows = this.db.prepare("SELECT id FROM nodes WHERE valid_to IS NULL AND last_updated_at > ?").all(ts);
+        return rows.map((r) => r.id);
+      }
+      /** Endpoints of edges TOUCHED since `ts` — created, re-seen, or CLOSED.
+       *  Closures matter as much as additions: a node that lost inflow is rank-dirty
+       *  while its own row never updated, so removal endpoints must seed the
+       *  incremental region or the stale inflow persists until the full backstop. */
+      edgeEndpointsTouchedSince(ts) {
+        const rows = this.db.prepare(
+          `SELECT from_id, to_id FROM edges
+         WHERE (valid_to IS NULL AND (created_at > :ts OR last_seen_at > :ts))
+            OR (valid_to IS NOT NULL AND valid_to > :ts)`
+        ).all({ ts });
+        return rows.map((r) => ({ from: r.from_id, to: r.to_id }));
+      }
+      /** Lightweight out-edges for a SET of sources, chunked IN-lists — the region
+       *  assembly path for incremental PageRank (per-node outEdges() at region
+       *  scale re-creates the 106k-prepared-calls problem the batch scan solved). */
+      outEdgesForMany(ids) {
+        return this.edgesForMany(ids, "from_id");
+      }
+      inEdgesForMany(ids) {
+        return this.edgesForMany(ids, "to_id");
+      }
+      /** Stored pageRank for a SET of ids (live rows only — a closed id is simply
+       *  absent, which is how incremental region assembly drops dead endpoints). */
+      ranksForMany(ids) {
+        const out2 = /* @__PURE__ */ new Map();
+        const CHUNK = 400;
+        for (let i2 = 0; i2 < ids.length; i2 += CHUNK) {
+          const chunk = ids.slice(i2, i2 + CHUNK);
+          const placeholders = chunk.map(() => "?").join(", ");
+          const rows = this.db.prepare(
+            `SELECT id, page_rank FROM nodes WHERE id IN (${placeholders}) AND valid_to IS NULL`
+          ).all(...chunk);
+          for (const r of rows) out2.set(r.id, r.page_rank);
+        }
+        return out2;
+      }
+      /** The minimal row set the landmark sweep needs — landmark CANDIDATES
+       *  (Pattern/RootCause), everything currently flagged, and every
+       *  persistent-tier node (force-landmarks). A few thousand rows, so the
+       *  incremental path can refresh the GLOBAL landmark set without the 179k-row
+       *  scanLiveNodes materialization. */
+      landmarkSweepRows() {
+        const rows = this.db.prepare(
+          `SELECT id, label, page_rank, is_landmark, memory_tier, extraction_source FROM nodes
+         WHERE valid_to IS NULL
+           AND (memory_tier = 'persistent' OR is_landmark = 1 OR label IN ('Pattern', 'RootCause'))`
+        ).all();
+        return rows.map((r) => ({
+          id: r.id,
+          label: r.label,
+          pageRank: r.page_rank,
+          isLandmark: r.is_landmark === 1,
+          memoryTier: r.memory_tier,
+          extractionSource: r.extraction_source
+        }));
+      }
+      edgesForMany(ids, col) {
+        const out2 = [];
+        const CHUNK = 400;
+        for (let i2 = 0; i2 < ids.length; i2 += CHUNK) {
+          const chunk = ids.slice(i2, i2 + CHUNK);
+          const placeholders = chunk.map(() => "?").join(", ");
+          const rows = this.db.prepare(
+            `SELECT from_id, to_id, type FROM edges WHERE ${col} IN (${placeholders}) AND valid_to IS NULL`
+          ).all(...chunk);
+          for (const r of rows) out2.push({ from: r.from_id, to: r.to_id, type: r.type });
+        }
+        return out2;
+      }
+      checkpointWal() {
+        try {
+          const r = this.db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+          return r ?? null;
+        } catch {
+          return null;
+        }
+      }
       reviveReobserved(relPaths, workspaceId2, since) {
         let revived = 0;
         const CHUNK = 400;
@@ -20199,7 +20294,7 @@ function pagerank(input) {
   const ids = input.nodeIds;
   const n = ids.length;
   if (n === 0) {
-    return { scores: /* @__PURE__ */ new Map(), iterations: 0, converged: true };
+    return { scores: /* @__PURE__ */ new Map(), iterations: 0, converged: true, danglingRank: 0 };
   }
   const index = /* @__PURE__ */ new Map();
   for (let i2 = 0; i2 < n; i2++) index.set(ids[i2], i2);
@@ -20271,8 +20366,12 @@ function pagerank(input) {
     }
   }
   const scores = /* @__PURE__ */ new Map();
-  for (let i2 = 0; i2 < n; i2++) scores.set(ids[i2], score2[i2]);
-  return { scores, iterations: iter, converged };
+  let danglingRank = 0;
+  for (let i2 = 0; i2 < n; i2++) {
+    scores.set(ids[i2], score2[i2]);
+    if (dangling[i2]) danglingRank += score2[i2];
+  }
+  return { scores, iterations: iter, converged, danglingRank };
 }
 function markLandmarks(scores, percentile = 0.1, filter) {
   const entries = [...scores.entries()];
@@ -20282,7 +20381,7 @@ function markLandmarks(scores, percentile = 0.1, filter) {
     }
   }
   if (entries.length === 0) return /* @__PURE__ */ new Set();
-  entries.sort((a, b) => b[1] - a[1]);
+  entries.sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
   const cutoff = Math.max(1, Math.floor(entries.length * percentile));
   const out2 = /* @__PURE__ */ new Set();
   for (let i2 = 0; i2 < cutoff; i2++) {
@@ -20739,6 +20838,92 @@ var init_bko = __esm({
   }
 });
 
+// ../../packages/math/src/pagerank-local.ts
+function pagerankLocal(input) {
+  const damping = input.damping ?? 0.85;
+  const tol = input.tolerance ?? 1e-6;
+  const maxIter = input.maxIterations ?? 100;
+  const ids = input.regionIds;
+  const n = ids.length;
+  if (n === 0 || input.globalN === 0) {
+    return { scores: /* @__PURE__ */ new Map(), iterations: 0, converged: true };
+  }
+  const index = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < n; i2++) index.set(ids[i2], i2);
+  const base = (1 - damping) / input.globalN;
+  const outSum = new Float64Array(n);
+  const inflow = new Float64Array(n);
+  let score2 = new Float64Array(n);
+  for (let i2 = 0; i2 < n; i2++) {
+    const id = ids[i2];
+    outSum[i2] = input.outSum.get(id) ?? 0;
+    inflow[i2] = input.boundaryInflow.get(id) ?? 0;
+    score2[i2] = input.rank0.get(id) ?? base;
+  }
+  const rowLen = new Int32Array(n);
+  let edgeCount = 0;
+  for (const [from, edges] of input.out) {
+    const fi = index.get(from);
+    if (fi === void 0) continue;
+    let inSet = 0;
+    for (const e of edges) if (index.has(e.to)) inSet++;
+    rowLen[fi] = inSet;
+    edgeCount += inSet;
+  }
+  const rowStart = new Int32Array(n + 1);
+  for (let i2 = 0; i2 < n; i2++) rowStart[i2 + 1] = rowStart[i2] + rowLen[i2];
+  const colIdx = new Int32Array(edgeCount);
+  const colW = new Float64Array(edgeCount);
+  const cursor = rowStart.slice(0, n);
+  for (const [from, edges] of input.out) {
+    const fi = index.get(from);
+    if (fi === void 0) continue;
+    for (const e of edges) {
+      const ti = index.get(e.to);
+      if (ti === void 0) continue;
+      const c = cursor[fi];
+      cursor[fi] = c + 1;
+      colIdx[c] = ti;
+      colW[c] = e.weight;
+    }
+  }
+  const externalDangling = input.externalDanglingRank ?? 0;
+  let next = new Float64Array(n);
+  let iter = 0;
+  let converged = false;
+  for (; iter < maxIter; iter++) {
+    let internalDangling = 0;
+    for (let i2 = 0; i2 < n; i2++) if (outSum[i2] <= 0) internalDangling += score2[i2];
+    const danglingShare = damping * (internalDangling + externalDangling) / input.globalN;
+    for (let i2 = 0; i2 < n; i2++) next[i2] = base + danglingShare + damping * inflow[i2];
+    for (let i2 = 0; i2 < n; i2++) {
+      const os2 = outSum[i2];
+      if (os2 <= 0) continue;
+      const f = damping * score2[i2] / os2;
+      const end = rowStart[i2 + 1];
+      for (let c = rowStart[i2]; c < end; c++) next[colIdx[c]] += f * colW[c];
+    }
+    let diff = 0;
+    for (let i2 = 0; i2 < n; i2++) diff += Math.abs(next[i2] - score2[i2]);
+    const tmp = score2;
+    score2 = next;
+    next = tmp;
+    if (diff < tol) {
+      iter++;
+      converged = true;
+      break;
+    }
+  }
+  const scores = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < n; i2++) scores.set(ids[i2], score2[i2]);
+  return { scores, iterations: iter, converged };
+}
+var init_pagerank_local = __esm({
+  "../../packages/math/src/pagerank-local.ts"() {
+    "use strict";
+  }
+});
+
 // ../../packages/math/src/index.ts
 var init_src4 = __esm({
   "../../packages/math/src/index.ts"() {
@@ -20762,6 +20947,7 @@ var init_src4 = __esm({
     init_spectral();
     init_motif_gate();
     init_bko();
+    init_pagerank_local();
   }
 });
 
@@ -29194,7 +29380,161 @@ var init_motifs = __esm({
 });
 
 // ../../packages/generalizer/src/nightly.ts
-function runGraphRescore(store) {
+function runGraphRescore(store, opts = {}) {
+  const lastRescoreAt = Number(store.getMeta?.("lastRescoreAt") ?? 0);
+  const sinceFull = Number(store.getMeta?.("rescoresSinceFull") ?? 0);
+  const incrementalCapable = !opts.forceFull && lastRescoreAt > 0 && sinceFull < FULL_RESCORE_EVERY - 1 && !!store.getMeta && !!store.setMeta && !!store.dirtyNodeIdsSince && !!store.edgeEndpointsTouchedSince && !!store.outEdgesForMany && !!store.inEdgesForMany && !!store.ranksForMany && !!store.landmarkSweepRows;
+  if (incrementalCapable) {
+    const started2 = Date.now();
+    const inc = tryIncrementalRescore(store, lastRescoreAt, started2);
+    if (inc) {
+      store.setMeta("lastRescoreAt", String(started2));
+      store.setMeta("rescoresSinceFull", String(sinceFull + 1));
+      return inc;
+    }
+  }
+  const report = runFullRescore(store);
+  store.setMeta?.("lastRescoreAt", String(report.startedAt));
+  store.setMeta?.("rescoresSinceFull", "0");
+  store.setMeta?.("danglingRankShare", String(report.danglingRank));
+  const { startedAt: _drop, danglingRank: _drop2, ...rest2 } = report;
+  return rest2;
+}
+function tryIncrementalRescore(store, lastRescoreAt, started2) {
+  const allowedTypes = new Set(pagerankEdgeTypes());
+  const liveN = store.nodeCount();
+  const cap = Math.max(1e3, Math.floor(liveN * INCREMENTAL_REGION_MAX_FRACTION));
+  const region = new Set(store.dirtyNodeIdsSince(lastRescoreAt));
+  for (const e of store.edgeEndpointsTouchedSince(lastRescoreAt)) {
+    region.add(e.from);
+    region.add(e.to);
+  }
+  if (region.size > cap) return null;
+  let frontier = [...region];
+  for (let hop = 0; hop < INCREMENTAL_HOPS && frontier.length > 0; hop++) {
+    const next = [];
+    for (const e of store.outEdgesForMany(frontier)) {
+      if (!allowedTypes.has(e.type)) continue;
+      if (!region.has(e.to)) {
+        region.add(e.to);
+        next.push(e.to);
+      }
+    }
+    if (region.size > cap) return null;
+    frontier = next;
+  }
+  const rank0 = store.ranksForMany([...region]);
+  const regionIds = [...rank0.keys()];
+  if (regionIds.length === 0) {
+    return {
+      scoredNodes: 0,
+      iterations: 0,
+      converged: true,
+      landmarks: 0,
+      communities: 0,
+      motifsPromoted: 0,
+      techniques: 0,
+      antipatterns: 0,
+      pageRankWritten: 0,
+      landmarkFlips: 0,
+      mode: "incremental",
+      regionSize: 0,
+      durationMs: Date.now() - started2
+    };
+  }
+  const inRegion = new Set(regionIds);
+  const out2 = /* @__PURE__ */ new Map();
+  const outSum = /* @__PURE__ */ new Map();
+  for (const e of store.outEdgesForMany(regionIds)) {
+    if (!allowedTypes.has(e.type)) continue;
+    const w = EDGE_WEIGHT[e.type] ?? 1;
+    if (w <= 0) continue;
+    outSum.set(e.from, (outSum.get(e.from) ?? 0) + w);
+    if (!inRegion.has(e.to)) continue;
+    const l = out2.get(e.from);
+    if (l) l.push({ to: e.to, weight: w });
+    else out2.set(e.from, [{ to: e.to, weight: w }]);
+  }
+  const boundaryEdges = store.inEdgesForMany(regionIds).filter((e) => allowedTypes.has(e.type) && !inRegion.has(e.from) && (EDGE_WEIGHT[e.type] ?? 1) > 0);
+  const boundarySources = [...new Set(boundaryEdges.map((e) => e.from))];
+  if (boundarySources.length > cap) return null;
+  const boundaryRanks = store.ranksForMany(boundarySources);
+  const boundaryOutSum = /* @__PURE__ */ new Map();
+  for (const e of store.outEdgesForMany(boundarySources)) {
+    if (!allowedTypes.has(e.type)) continue;
+    const w = EDGE_WEIGHT[e.type] ?? 1;
+    if (w > 0) boundaryOutSum.set(e.from, (boundaryOutSum.get(e.from) ?? 0) + w);
+  }
+  const boundaryInflow = /* @__PURE__ */ new Map();
+  for (const e of boundaryEdges) {
+    const r = boundaryRanks.get(e.from);
+    const os2 = boundaryOutSum.get(e.from);
+    if (r === void 0 || !os2) continue;
+    const w = EDGE_WEIGHT[e.type] ?? 1;
+    boundaryInflow.set(e.to, (boundaryInflow.get(e.to) ?? 0) + r * w / os2);
+  }
+  const globalDangling = Number(store.getMeta("danglingRankShare") ?? 0);
+  let regionDangling = 0;
+  for (const id of regionIds) {
+    if ((outSum.get(id) ?? 0) <= 0) regionDangling += rank0.get(id) ?? 0;
+  }
+  const result = pagerankLocal({
+    regionIds,
+    rank0,
+    out: out2,
+    outSum,
+    boundaryInflow,
+    globalN: liveN,
+    externalDanglingRank: Math.max(0, globalDangling - regionDangling),
+    damping: 0.85,
+    tolerance: 1e-6,
+    maxIterations: 100
+  });
+  let pageRankWritten = 0;
+  store.transaction(() => {
+    for (const [id, score2] of result.scores) {
+      if (Math.abs(score2 - (rank0.get(id) ?? 0)) < 1e-9) continue;
+      store.setPageRank(id, score2);
+      pageRankWritten++;
+    }
+  });
+  const sweep = store.landmarkSweepRows();
+  const candidates = /* @__PURE__ */ new Map();
+  for (const row of sweep) {
+    if (row.label === "Pattern" || row.label === "RootCause") {
+      candidates.set(row.id, result.scores.get(row.id) ?? row.pageRank);
+    }
+  }
+  const want = markLandmarks(candidates, 0.1);
+  for (const row of sweep) if (row.memoryTier === "persistent") want.add(row.id);
+  let landmarkFlips = 0;
+  store.transaction(() => {
+    for (const row of sweep) {
+      if (row.extractionSource === "bko-inferred") continue;
+      const should = want.has(row.id);
+      if (row.isLandmark === should) continue;
+      store.setLandmark(row.id, should);
+      landmarkFlips++;
+    }
+  });
+  return {
+    scoredNodes: regionIds.length,
+    iterations: result.iterations,
+    converged: result.converged,
+    landmarks: want.size,
+    communities: 0,
+    // deferred to the full backstop — see mode docs
+    motifsPromoted: 0,
+    techniques: 0,
+    antipatterns: 0,
+    pageRankWritten,
+    landmarkFlips,
+    mode: "incremental",
+    regionSize: regionIds.length,
+    durationMs: Date.now() - started2
+  };
+}
+function runFullRescore(store) {
   const started2 = Date.now();
   const allowedTypes = new Set(pagerankEdgeTypes());
   const nodeIds = [];
@@ -29220,10 +29560,12 @@ function runGraphRescore(store) {
     maxIterations: 100
   });
   const scored = result.scores.size;
+  let pageRankWritten = 0;
   store.transaction(() => {
     for (const [id, score2] of result.scores) {
       if (Math.abs(score2 - (meta3.get(id)?.pageRank ?? 0)) < 1e-9) continue;
       store.setPageRank(id, score2);
+      pageRankWritten++;
     }
   });
   const landmarkCandidates = /* @__PURE__ */ new Map();
@@ -29238,11 +29580,13 @@ function runGraphRescore(store) {
   for (const id of nodeIds) {
     if (meta3.get(id)?.memoryTier === "persistent") allLandmarks.add(id);
   }
+  let landmarkFlips = 0;
   store.transaction(() => {
     for (const id of nodeIds) {
       const want = allLandmarks.has(id);
       if ((meta3.get(id)?.isLandmark ?? false) === want) continue;
       store.setLandmark(id, want);
+      landmarkFlips++;
     }
   });
   const MOTIF_LABELS = /* @__PURE__ */ new Set(["Pattern", "Technique", "AntiPattern"]);
@@ -29286,6 +29630,12 @@ function runGraphRescore(store) {
     motifsPromoted: motifs.promoted,
     techniques: motifs.techniques,
     antipatterns: motifs.antipatterns,
+    pageRankWritten,
+    landmarkFlips,
+    mode: "full",
+    regionSize: 0,
+    startedAt: started2,
+    danglingRank: result.danglingRank,
     durationMs: Date.now() - started2
   };
 }
@@ -29323,6 +29673,10 @@ function runNightlyPipeline(store) {
     skillsInduced: 0,
     // skills are cloud-induced now (see above)
     skillsRefreshed: 0,
+    pageRankWritten: rescore.pageRankWritten,
+    landmarkFlips: rescore.landmarkFlips,
+    mode: rescore.mode,
+    regionSize: rescore.regionSize,
     designResolved: semantic.designResolved,
     revisitsCleared: semantic.revisitsCleared,
     fixCandidatesSettled: semantic.fixCandidatesSettled,
@@ -29353,6 +29707,7 @@ function codeAnchorProjection(store, semanticIds, opts = {}) {
   }
   return out2;
 }
+var FULL_RESCORE_EVERY, INCREMENTAL_REGION_MAX_FRACTION, INCREMENTAL_HOPS;
 var init_nightly = __esm({
   "../../packages/generalizer/src/nightly.ts"() {
     "use strict";
@@ -29360,6 +29715,9 @@ var init_nightly = __esm({
     init_src4();
     init_src5();
     init_motifs();
+    FULL_RESCORE_EVERY = 12;
+    INCREMENTAL_REGION_MAX_FRACTION = 0.2;
+    INCREMENTAL_HOPS = 3;
   }
 });
 
@@ -29595,6 +29953,8 @@ var init_relevance_rank = __esm({
 // ../../packages/generalizer/src/index.ts
 var src_exports4 = {};
 __export(src_exports4, {
+  FULL_RESCORE_EVERY: () => FULL_RESCORE_EVERY,
+  INCREMENTAL_REGION_MAX_FRACTION: () => INCREMENTAL_REGION_MAX_FRACTION,
   anchorByLine: () => anchorByLine,
   anchorCandidates: () => anchorCandidates,
   anchorProblemToCode: () => anchorProblemToCode,
@@ -53284,6 +53644,8 @@ function editSurprise(d) {
 function episodeId(workspaceId2, t) {
   return `episode_${digest({ kind: "episode", workspaceId: workspaceId2, t }).slice(0, 16)}`;
 }
+var EPISODE_DELTA_CAP = 200;
+var EPISODE_PRODUCED_CAP = 500;
 function producedEdge(from, to, t) {
   return {
     id: `edge_${digest({ from, type: "PRODUCED", to }).slice(0, 16)}`,
@@ -53305,6 +53667,10 @@ function recordEpisode(store, workspaceId2, t, delta, causal) {
   if (deltaIsEmpty(delta)) return null;
   const id = episodeId(workspaceId2, t);
   const surprise = editSurprise(delta);
+  const overCap = delta.symbols.length > EPISODE_DELTA_CAP || delta.symbols.length > EPISODE_PRODUCED_CAP;
+  const changeRank = { changed: 0, added: 1, removed: 2 };
+  const prioritized = overCap ? [...delta.symbols].sort((a, b) => changeRank[a.change] - changeRank[b.change]) : delta.symbols;
+  const storedDelta = prioritized.slice(0, EPISODE_DELTA_CAP);
   const node2 = {
     id,
     label: "Episode",
@@ -53336,8 +53702,11 @@ function recordEpisode(store, workspaceId2, t, delta, causal) {
       edgesAdded: delta.edgesAdded,
       edgesRemoved: delta.edgesRemoved,
       editSurprise: surprise,
-      // The per-symbol structural delta (signatures before→after, no raw text).
-      delta: delta.symbols,
+      // The per-symbol structural delta (signatures before→after, no raw text),
+      // capped changed-first; the aggregate counts above always cover the whole
+      // edit, so nothing about the edit's MAGNITUDE is lost to the cap.
+      delta: storedDelta,
+      ...delta.symbols.length > EPISODE_DELTA_CAP ? { deltaTotal: delta.symbols.length } : {},
       // Causal context from the agent's tool stream, when correlated. Project
       // ONLY the scrub-safe fields — opaque session id, enum tool, closed-vocab
       // hints. declaredRenames carry identifier names (consumed upstream as
@@ -53352,11 +53721,14 @@ function recordEpisode(store, workspaceId2, t, delta, causal) {
     }
   };
   store.transaction(() => {
+    let minted = 0;
     store.mergeNode(node2);
-    for (const s of delta.symbols) {
+    for (const s of prioritized) {
       if (s.change === "removed") continue;
+      if (minted >= EPISODE_PRODUCED_CAP) break;
       if (store.getNode(s.nodeId)) {
         store.mergeEdge(producedEdge(id, s.nodeId, t));
+        minted++;
       }
       if (s.change === "changed") {
         const live = store.getNode(s.nodeId);
@@ -53364,6 +53736,7 @@ function recordEpisode(store, workspaceId2, t, delta, causal) {
         const frozenId = `${s.nodeId}@v${prev}`;
         if (store.getNode(frozenId)) {
           store.mergeEdge(producedEdge(id, frozenId, t));
+          minted++;
         }
       }
     }
@@ -53371,6 +53744,49 @@ function recordEpisode(store, workspaceId2, t, delta, causal) {
   return id;
 }
 
+// src/episode-retention.ts
+var EPISODE_RETAIN_DAYS_DEFAULT = 90;
+var EPISODE_RETIRE_BATCH_DEFAULT = 300;
+var DAY_MS = 864e5;
+function numEnv(key, fallback) {
+  const raw2 = process.env[key];
+  if (raw2 == null || raw2.trim() === "") return fallback;
+  const n = Number(raw2);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function retireEpisodeProvenance(store, now, opts = {}) {
+  const retainDays = opts.retainDays ?? numEnv("ERRATA_EPISODE_RETAIN_DAYS", EPISODE_RETAIN_DAYS_DEFAULT);
+  const batch = opts.batch ?? EPISODE_RETIRE_BATCH_DEFAULT;
+  const cutoff = now - retainDays * DAY_MS;
+  const due = store.findNodesByLabel("Episode").filter((ep) => {
+    if (ep.attrs["provenanceRetired"] != null) return false;
+    const ts = ep.attrs["ts"] ?? ep.createdAt;
+    return ts < cutoff;
+  }).sort((a, b) => (a.attrs["ts"] ?? a.createdAt) - (b.attrs["ts"] ?? b.createdAt)).slice(0, batch);
+  let edgesClosed = 0;
+  let deltasDropped = 0;
+  for (const ep of due) {
+    store.transaction(() => {
+      for (const e of store.outEdges(ep.id, ["PRODUCED"])) {
+        store.closeEdge(e.id, now);
+        edgesClosed++;
+      }
+      const { delta, ...rest2 } = ep.attrs;
+      if (Array.isArray(delta)) deltasDropped++;
+      store.updateNode(ep.id, {
+        attrs: {
+          ...rest2,
+          provenanceRetired: now,
+          // How much detail the compaction elided — the aggregate counts
+          // (symbolsAdded/Changed/Removed) still describe the edit itself.
+          ...Array.isArray(delta) ? { deltaDropped: delta.length } : {}
+        }
+      });
+    });
+  }
+  return { retired: due.length, edgesClosed, deltasDropped };
+}
+
 // src/pass-worker-client.ts
 import { Worker } from "node:worker_threads";
 var PassWorker = class {
@@ -54991,7 +55407,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.650" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.682" : "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;
@@ -56593,7 +57009,14 @@ function createWorkspaceEngine(opts) {
         scoredNodes: report.scoredNodes,
         landmarks: report.landmarks,
         communities: report.communities,
-        motifsPromoted: report.motifsPromoted
+        motifsPromoted: report.motifsPromoted,
+        // Consumer-visible effect (momentum-gate calibration reads these):
+        // a run of zero-flip rows is the gate learning to fire less.
+        pageRankWritten: report.pageRankWritten,
+        landmarkFlips: report.landmarkFlips,
+        // HZ-incremental-pagerank: 1 = full backstop, 0 = dirty-region solve.
+        fullPass: report.mode === "full" ? 1 : 0,
+        regionSize: report.regionSize
       });
       appendPassLedger(paths.configDir, "semantic-maintenance", report.durationMs, {
         revisitsCleared: report.revisitsCleared,
@@ -56601,6 +57024,26 @@ function createWorkspaceEngine(opts) {
         designResolved: report.designResolved,
         claimsEvaluated: report.claimsEvaluated
       });
+      try {
+        const t0 = Date.now();
+        const ret = retireEpisodeProvenance(store, t0);
+        if (ret.retired > 0) {
+          appendPassLedger(paths.configDir, "provenance-retire", Date.now() - t0, {
+            episodes: ret.retired,
+            edgesClosed: ret.edgesClosed,
+            deltasDropped: ret.deltasDropped
+          });
+        }
+      } catch (err2) {
+        console.warn("[errata] provenance retention failed:", err2.message?.slice(0, 120));
+      }
+      try {
+        const cp = store.checkpointWal?.();
+        if (cp && cp.busy === 0 && cp.log > 25e3) {
+          console.log(`[errata] wal checkpoint: truncated ${cp.log} frame(s)`);
+        }
+      } catch {
+      }
       return report;
     },
     async embedSettled() {
@@ -58623,9 +59066,11 @@ async function startMultiDaemon(opts = {}) {
       }
       return out2;
     },
-    async nightlyAll() {
+    async nightlyFor(ids) {
+      const want = new Set(ids);
       const out2 = /* @__PURE__ */ new Map();
       for (const r of records) {
+        if (!want.has(r.id)) continue;
         const done = markPass(`nightly:${r.entry.name}`);
         try {
           out2.set(r.id, await r.engine.nightly());
@@ -58637,6 +59082,9 @@ async function startMultiDaemon(opts = {}) {
       }
       return out2;
     },
+    async nightlyAll() {
+      return daemon.nightlyFor(records.map((r) => r.id));
+    },
     async percolateAll() {
       const ts = Date.now();
       const out2 = /* @__PURE__ */ new Map();
@@ -59779,16 +60227,28 @@ function formatWhoami(response, localProfile) {
 }
 
 // src/consolidation-trigger.ts
+function effectiveMomentumThreshold(policy, liveNodes) {
+  return Math.max(policy.momentumThreshold, Math.ceil(liveNodes * policy.momentumRatio));
+}
+function nextMomentumThreshold(args2) {
+  const { current, consumed, landmarkFlips, floor, cap } = args2;
+  const next = landmarkFlips > 0 ? Math.min(current, Math.round(consumed / 2)) : Math.max(current, Math.round(consumed * 1.5));
+  return Math.max(floor, Math.min(cap, next));
+}
 var DEFAULT_CONSOLIDATION_POLICY = {
   baseFloorMs: 6e4,
   dutyFactor: 20,
   // ≤5% worst-case duty at any graph size (crater guard)
   momentumThreshold: 500,
-  // significance: ~mutations needed to meaningfully move PageRank
+  // POLICY freshness bound — the gate never demands less
+  momentumRatio: 0.01,
+  // cold-start PRIOR only; calibration replaces it after the first pass
+  momentumRatioCap: 0.05,
+  // POLICY staleness bound — refresh by 5% churn no matter what
   quiescenceMs: 6e4
   // sim preferred 60s over 90s (fresher, esp. heavy-code)
 };
-function numEnv(env2, key, fallback) {
+function numEnv2(env2, key, fallback) {
   const raw2 = env2[key];
   if (raw2 == null || raw2.trim() === "") return fallback;
   const n = Number(raw2);
@@ -59796,21 +60256,17 @@ function numEnv(env2, key, fallback) {
 }
 function consolidationPolicyFromEnv(env2 = process.env) {
   return {
-    baseFloorMs: numEnv(env2, "ERRATA_CONSOLIDATE_BASE_FLOOR_MS", DEFAULT_CONSOLIDATION_POLICY.baseFloorMs),
-    dutyFactor: numEnv(env2, "ERRATA_CONSOLIDATE_DUTY_FACTOR", DEFAULT_CONSOLIDATION_POLICY.dutyFactor),
-    momentumThreshold: numEnv(env2, "ERRATA_CONSOLIDATE_MOMENTUM", DEFAULT_CONSOLIDATION_POLICY.momentumThreshold),
-    quiescenceMs: numEnv(env2, "ERRATA_CONSOLIDATE_QUIESCENCE_MS", DEFAULT_CONSOLIDATION_POLICY.quiescenceMs)
+    baseFloorMs: numEnv2(env2, "ERRATA_CONSOLIDATE_BASE_FLOOR_MS", DEFAULT_CONSOLIDATION_POLICY.baseFloorMs),
+    dutyFactor: numEnv2(env2, "ERRATA_CONSOLIDATE_DUTY_FACTOR", DEFAULT_CONSOLIDATION_POLICY.dutyFactor),
+    momentumThreshold: numEnv2(env2, "ERRATA_CONSOLIDATE_MOMENTUM", DEFAULT_CONSOLIDATION_POLICY.momentumThreshold),
+    momentumRatio: numEnv2(env2, "ERRATA_CONSOLIDATE_MOMENTUM_RATIO", DEFAULT_CONSOLIDATION_POLICY.momentumRatio),
+    momentumRatioCap: numEnv2(env2, "ERRATA_CONSOLIDATE_MOMENTUM_RATIO_CAP", DEFAULT_CONSOLIDATION_POLICY.momentumRatioCap),
+    quiescenceMs: numEnv2(env2, "ERRATA_CONSOLIDATE_QUIESCENCE_MS", DEFAULT_CONSOLIDATION_POLICY.quiescenceMs)
   };
 }
 function consolidationGapMs(lastPassMs, policy) {
   return Math.max(policy.baseFloorMs, lastPassMs * policy.dutyFactor);
 }
-function shouldConsolidate(args2) {
-  const { now, state, policy, force = false } = args2;
-  if (state.momentum < policy.momentumThreshold) return false;
-  if (force) return true;
-  return now - state.lastConsolidationEnd >= consolidationGapMs(state.lastPassMs, policy);
-}
 
 // src/cli.ts
 var exitCleanOnEpipe = (err2) => {
@@ -62170,10 +62626,10 @@ async function cmdDash(args2) {
   let nightlyCount = 0;
   const hotspotScanMark = /* @__PURE__ */ new Map();
   const HOTSPOT_FANIN = 20;
-  const runNightlyPass = async () => {
+  const runNightlyPass = async (dueIds) => {
     const yieldToLoop2 = () => new Promise((resolve6) => setImmediate(resolve6));
     const fullReclusterPass = nightlyCount++ % FULL_RECLUSTER_EVERY === 0;
-    const m = await handle2.nightlyAll();
+    const m = dueIds ? await handle2.nightlyFor(dueIds) : await handle2.nightlyAll();
     let skillsLearned = 0;
     for (const [id, n] of m) {
       skillsLearned += n.skillsInduced;
@@ -62317,36 +62773,57 @@ async function cmdDash(args2) {
       }
     }
     maybeFlushDigests();
+    return m;
   };
   const CONSOLIDATE_BOOT_GRACE_S = 45;
   const consolidationPolicy = consolidationPolicyFromEnv();
   const consolidationState = { momentum: 0, lastConsolidationEnd: 0, lastPassMs: 0 };
-  const totalMutations = () => handle2.records.reduce((n, r) => n + r.engine.store.mutationCount(), 0);
-  let consolidatedAtMutations = 0;
+  const consolidatedAtByRecord = /* @__PURE__ */ new Map();
+  const calibratedThreshold = /* @__PURE__ */ new Map();
+  const thresholdFor = (r) => calibratedThreshold.get(r.id) ?? effectiveMomentumThreshold(consolidationPolicy, r.engine.store.nodeCount());
+  const dueRecords = () => handle2.records.map((r) => ({
+    id: r.id,
+    momentum: r.engine.store.mutationCount() - (consolidatedAtByRecord.get(r.id) ?? 0),
+    threshold: thresholdFor(r)
+  })).filter((x) => x.momentum >= x.threshold).map(({ id, momentum }) => ({ id, momentum }));
   let consolidating = false;
   const maybeConsolidate = async (force) => {
     if (consolidating) return;
     if (process.uptime() < CONSOLIDATE_BOOT_GRACE_S) return;
-    consolidationState.momentum = totalMutations() - consolidatedAtMutations;
-    if (!shouldConsolidate({
-      now: Date.now(),
-      state: consolidationState,
-      policy: consolidationPolicy,
-      force
-    })) {
+    const due = dueRecords();
+    consolidationState.momentum = due.length;
+    if (due.length === 0) return;
+    if (!force && Date.now() - consolidationState.lastConsolidationEnd < consolidationGapMs(consolidationState.lastPassMs, consolidationPolicy)) {
       return;
     }
     consolidating = true;
     const startedAt = Date.now();
     try {
-      await runNightlyPass();
+      const reports = await runNightlyPass(due.map((d) => d.id));
+      for (const { id, momentum } of due) {
+        const r = handle2.records.find((x) => x.id === id);
+        const report = reports?.get(id);
+        if (!r || !report) continue;
+        calibratedThreshold.set(
+          id,
+          nextMomentumThreshold({
+            current: thresholdFor(r),
+            consumed: momentum,
+            landmarkFlips: report.landmarkFlips,
+            floor: consolidationPolicy.momentumThreshold,
+            cap: Math.ceil(r.engine.store.nodeCount() * consolidationPolicy.momentumRatioCap)
+          })
+        );
+      }
     } catch (err2) {
       console.warn(`[consolidate] pass failed: ${err2 instanceof Error ? err2.message : err2}`);
     } finally {
       consolidationState.lastPassMs = Date.now() - startedAt;
       consolidationState.lastConsolidationEnd = Date.now();
-      consolidatedAtMutations = totalMutations();
-      consolidationState.momentum = 0;
+      for (const { id } of due) {
+        const r = handle2.records.find((x) => x.id === id);
+        if (r) consolidatedAtByRecord.set(id, r.engine.store.mutationCount());
+      }
       consolidating = false;
     }
   };

package/package.json

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

package/pass-worker.mjs

@@ -266,6 +266,10 @@ var init_castalia = __esm({
       // git topology, not signal-flow
       "AUTHORED_BY",
       // git authorship, not signal-flow
+      "PRODUCED",
+      // edit-episode provenance (Episode→symbol), not signal-flow — the family
+      // above was excluded together but this member slipped the net (LC-produced-pagerank);
+      // at 43% of all live edges it was the largest single edge population flowing rank
       "CONTRIBUTED",
       // agent attribution (Agent → knowledge), not signal-flow
       "SUPERSEDES",
@@ -15436,6 +15440,7 @@ function openDatabase(path) {
       db.exec("PRAGMA journal_mode = WAL");
       db.exec("PRAGMA synchronous = NORMAL");
       db.exec("PRAGMA busy_timeout = 5000");
+      db.exec("PRAGMA journal_size_limit = 67108864");
     } catch {
     }
   }
@@ -24903,6 +24908,96 @@ var SqliteGraphStore = class {
     const rows = this.db.prepare("SELECT from_id, to_id, type FROM edges WHERE valid_to IS NULL").all();
     return rows.map((r) => ({ from: r.from_id, to: r.to_id, type: r.type }));
   }
+  getMeta(key) {
+    const r = this.db.prepare("SELECT value FROM store_meta WHERE key = ?").get(key);
+    return r?.value ?? null;
+  }
+  setMeta(key, value) {
+    this.db.prepare(
+      "INSERT INTO store_meta (key, value) VALUES (:key, :value) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+    ).run({ key, value });
+  }
+  dirtyNodeIdsSince(ts) {
+    const rows = this.db.prepare("SELECT id FROM nodes WHERE valid_to IS NULL AND last_updated_at > ?").all(ts);
+    return rows.map((r) => r.id);
+  }
+  /** Endpoints of edges TOUCHED since `ts` — created, re-seen, or CLOSED.
+   *  Closures matter as much as additions: a node that lost inflow is rank-dirty
+   *  while its own row never updated, so removal endpoints must seed the
+   *  incremental region or the stale inflow persists until the full backstop. */
+  edgeEndpointsTouchedSince(ts) {
+    const rows = this.db.prepare(
+      `SELECT from_id, to_id FROM edges
+         WHERE (valid_to IS NULL AND (created_at > :ts OR last_seen_at > :ts))
+            OR (valid_to IS NOT NULL AND valid_to > :ts)`
+    ).all({ ts });
+    return rows.map((r) => ({ from: r.from_id, to: r.to_id }));
+  }
+  /** Lightweight out-edges for a SET of sources, chunked IN-lists — the region
+   *  assembly path for incremental PageRank (per-node outEdges() at region
+   *  scale re-creates the 106k-prepared-calls problem the batch scan solved). */
+  outEdgesForMany(ids) {
+    return this.edgesForMany(ids, "from_id");
+  }
+  inEdgesForMany(ids) {
+    return this.edgesForMany(ids, "to_id");
+  }
+  /** Stored pageRank for a SET of ids (live rows only — a closed id is simply
+   *  absent, which is how incremental region assembly drops dead endpoints). */
+  ranksForMany(ids) {
+    const out2 = /* @__PURE__ */ new Map();
+    const CHUNK = 400;
+    for (let i2 = 0; i2 < ids.length; i2 += CHUNK) {
+      const chunk = ids.slice(i2, i2 + CHUNK);
+      const placeholders = chunk.map(() => "?").join(", ");
+      const rows = this.db.prepare(
+        `SELECT id, page_rank FROM nodes WHERE id IN (${placeholders}) AND valid_to IS NULL`
+      ).all(...chunk);
+      for (const r of rows) out2.set(r.id, r.page_rank);
+    }
+    return out2;
+  }
+  /** The minimal row set the landmark sweep needs — landmark CANDIDATES
+   *  (Pattern/RootCause), everything currently flagged, and every
+   *  persistent-tier node (force-landmarks). A few thousand rows, so the
+   *  incremental path can refresh the GLOBAL landmark set without the 179k-row
+   *  scanLiveNodes materialization. */
+  landmarkSweepRows() {
+    const rows = this.db.prepare(
+      `SELECT id, label, page_rank, is_landmark, memory_tier, extraction_source FROM nodes
+         WHERE valid_to IS NULL
+           AND (memory_tier = 'persistent' OR is_landmark = 1 OR label IN ('Pattern', 'RootCause'))`
+    ).all();
+    return rows.map((r) => ({
+      id: r.id,
+      label: r.label,
+      pageRank: r.page_rank,
+      isLandmark: r.is_landmark === 1,
+      memoryTier: r.memory_tier,
+      extractionSource: r.extraction_source
+    }));
+  }
+  edgesForMany(ids, col) {
+    const out2 = [];
+    const CHUNK = 400;
+    for (let i2 = 0; i2 < ids.length; i2 += CHUNK) {
+      const chunk = ids.slice(i2, i2 + CHUNK);
+      const placeholders = chunk.map(() => "?").join(", ");
+      const rows = this.db.prepare(
+        `SELECT from_id, to_id, type FROM edges WHERE ${col} IN (${placeholders}) AND valid_to IS NULL`
+      ).all(...chunk);
+      for (const r of rows) out2.push({ from: r.from_id, to: r.to_id, type: r.type });
+    }
+    return out2;
+  }
+  checkpointWal() {
+    try {
+      const r = this.db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+      return r ?? null;
+    } catch {
+      return null;
+    }
+  }
   reviveReobserved(relPaths, workspaceId, since) {
     let revived = 0;
     const CHUNK = 400;
@@ -25926,7 +26021,7 @@ function pagerank(input) {
   const ids = input.nodeIds;
   const n = ids.length;
   if (n === 0) {
-    return { scores: /* @__PURE__ */ new Map(), iterations: 0, converged: true };
+    return { scores: /* @__PURE__ */ new Map(), iterations: 0, converged: true, danglingRank: 0 };
   }
   const index = /* @__PURE__ */ new Map();
   for (let i2 = 0; i2 < n; i2++) index.set(ids[i2], i2);
@@ -25998,8 +26093,12 @@ function pagerank(input) {
     }
   }
   const scores = /* @__PURE__ */ new Map();
-  for (let i2 = 0; i2 < n; i2++) scores.set(ids[i2], score2[i2]);
-  return { scores, iterations: iter, converged };
+  let danglingRank = 0;
+  for (let i2 = 0; i2 < n; i2++) {
+    scores.set(ids[i2], score2[i2]);
+    if (dangling[i2]) danglingRank += score2[i2];
+  }
+  return { scores, iterations: iter, converged, danglingRank };
 }
 function markLandmarks(scores, percentile = 0.1, filter) {
   const entries = [...scores.entries()];
@@ -26009,7 +26108,7 @@ function markLandmarks(scores, percentile = 0.1, filter) {
     }
   }
   if (entries.length === 0) return /* @__PURE__ */ new Set();
-  entries.sort((a, b) => b[1] - a[1]);
+  entries.sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
   const cutoff = Math.max(1, Math.floor(entries.length * percentile));
   const out2 = /* @__PURE__ */ new Set();
   for (let i2 = 0; i2 < cutoff; i2++) {
@@ -26247,6 +26346,87 @@ function motifDecision(input) {
   };
 }
 
+// ../../packages/math/src/pagerank-local.ts
+function pagerankLocal(input) {
+  const damping = input.damping ?? 0.85;
+  const tol = input.tolerance ?? 1e-6;
+  const maxIter = input.maxIterations ?? 100;
+  const ids = input.regionIds;
+  const n = ids.length;
+  if (n === 0 || input.globalN === 0) {
+    return { scores: /* @__PURE__ */ new Map(), iterations: 0, converged: true };
+  }
+  const index = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < n; i2++) index.set(ids[i2], i2);
+  const base = (1 - damping) / input.globalN;
+  const outSum = new Float64Array(n);
+  const inflow = new Float64Array(n);
+  let score2 = new Float64Array(n);
+  for (let i2 = 0; i2 < n; i2++) {
+    const id = ids[i2];
+    outSum[i2] = input.outSum.get(id) ?? 0;
+    inflow[i2] = input.boundaryInflow.get(id) ?? 0;
+    score2[i2] = input.rank0.get(id) ?? base;
+  }
+  const rowLen = new Int32Array(n);
+  let edgeCount = 0;
+  for (const [from, edges] of input.out) {
+    const fi = index.get(from);
+    if (fi === void 0) continue;
+    let inSet = 0;
+    for (const e of edges) if (index.has(e.to)) inSet++;
+    rowLen[fi] = inSet;
+    edgeCount += inSet;
+  }
+  const rowStart = new Int32Array(n + 1);
+  for (let i2 = 0; i2 < n; i2++) rowStart[i2 + 1] = rowStart[i2] + rowLen[i2];
+  const colIdx = new Int32Array(edgeCount);
+  const colW = new Float64Array(edgeCount);
+  const cursor = rowStart.slice(0, n);
+  for (const [from, edges] of input.out) {
+    const fi = index.get(from);
+    if (fi === void 0) continue;
+    for (const e of edges) {
+      const ti = index.get(e.to);
+      if (ti === void 0) continue;
+      const c = cursor[fi];
+      cursor[fi] = c + 1;
+      colIdx[c] = ti;
+      colW[c] = e.weight;
+    }
+  }
+  const externalDangling = input.externalDanglingRank ?? 0;
+  let next = new Float64Array(n);
+  let iter = 0;
+  let converged = false;
+  for (; iter < maxIter; iter++) {
+    let internalDangling = 0;
+    for (let i2 = 0; i2 < n; i2++) if (outSum[i2] <= 0) internalDangling += score2[i2];
+    const danglingShare = damping * (internalDangling + externalDangling) / input.globalN;
+    for (let i2 = 0; i2 < n; i2++) next[i2] = base + danglingShare + damping * inflow[i2];
+    for (let i2 = 0; i2 < n; i2++) {
+      const os2 = outSum[i2];
+      if (os2 <= 0) continue;
+      const f = damping * score2[i2] / os2;
+      const end = rowStart[i2 + 1];
+      for (let c = rowStart[i2]; c < end; c++) next[colIdx[c]] += f * colW[c];
+    }
+    let diff = 0;
+    for (let i2 = 0; i2 < n; i2++) diff += Math.abs(next[i2] - score2[i2]);
+    const tmp = score2;
+    score2 = next;
+    next = tmp;
+    if (diff < tol) {
+      iter++;
+      converged = true;
+      break;
+    }
+  }
+  const scores = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < n; i2++) scores.set(ids[i2], score2[i2]);
+  return { scores, iterations: iter, converged };
+}
+
 // ../../packages/local-graph/src/triage.ts
 init_src();
 init_src();
@@ -26394,7 +26574,164 @@ function promoteMotifs(store2, t) {
 }
 
 // ../../packages/generalizer/src/nightly.ts
-function runGraphRescore(store2) {
+var FULL_RESCORE_EVERY = 12;
+var INCREMENTAL_REGION_MAX_FRACTION = 0.2;
+var INCREMENTAL_HOPS = 3;
+function runGraphRescore(store2, opts = {}) {
+  const lastRescoreAt = Number(store2.getMeta?.("lastRescoreAt") ?? 0);
+  const sinceFull = Number(store2.getMeta?.("rescoresSinceFull") ?? 0);
+  const incrementalCapable = !opts.forceFull && lastRescoreAt > 0 && sinceFull < FULL_RESCORE_EVERY - 1 && !!store2.getMeta && !!store2.setMeta && !!store2.dirtyNodeIdsSince && !!store2.edgeEndpointsTouchedSince && !!store2.outEdgesForMany && !!store2.inEdgesForMany && !!store2.ranksForMany && !!store2.landmarkSweepRows;
+  if (incrementalCapable) {
+    const started = Date.now();
+    const inc = tryIncrementalRescore(store2, lastRescoreAt, started);
+    if (inc) {
+      store2.setMeta("lastRescoreAt", String(started));
+      store2.setMeta("rescoresSinceFull", String(sinceFull + 1));
+      return inc;
+    }
+  }
+  const report = runFullRescore(store2);
+  store2.setMeta?.("lastRescoreAt", String(report.startedAt));
+  store2.setMeta?.("rescoresSinceFull", "0");
+  store2.setMeta?.("danglingRankShare", String(report.danglingRank));
+  const { startedAt: _drop, danglingRank: _drop2, ...rest } = report;
+  return rest;
+}
+function tryIncrementalRescore(store2, lastRescoreAt, started) {
+  const allowedTypes = new Set(pagerankEdgeTypes());
+  const liveN = store2.nodeCount();
+  const cap = Math.max(1e3, Math.floor(liveN * INCREMENTAL_REGION_MAX_FRACTION));
+  const region = new Set(store2.dirtyNodeIdsSince(lastRescoreAt));
+  for (const e of store2.edgeEndpointsTouchedSince(lastRescoreAt)) {
+    region.add(e.from);
+    region.add(e.to);
+  }
+  if (region.size > cap) return null;
+  let frontier = [...region];
+  for (let hop = 0; hop < INCREMENTAL_HOPS && frontier.length > 0; hop++) {
+    const next = [];
+    for (const e of store2.outEdgesForMany(frontier)) {
+      if (!allowedTypes.has(e.type)) continue;
+      if (!region.has(e.to)) {
+        region.add(e.to);
+        next.push(e.to);
+      }
+    }
+    if (region.size > cap) return null;
+    frontier = next;
+  }
+  const rank0 = store2.ranksForMany([...region]);
+  const regionIds = [...rank0.keys()];
+  if (regionIds.length === 0) {
+    return {
+      scoredNodes: 0,
+      iterations: 0,
+      converged: true,
+      landmarks: 0,
+      communities: 0,
+      motifsPromoted: 0,
+      techniques: 0,
+      antipatterns: 0,
+      pageRankWritten: 0,
+      landmarkFlips: 0,
+      mode: "incremental",
+      regionSize: 0,
+      durationMs: Date.now() - started
+    };
+  }
+  const inRegion = new Set(regionIds);
+  const out2 = /* @__PURE__ */ new Map();
+  const outSum = /* @__PURE__ */ new Map();
+  for (const e of store2.outEdgesForMany(regionIds)) {
+    if (!allowedTypes.has(e.type)) continue;
+    const w = EDGE_WEIGHT[e.type] ?? 1;
+    if (w <= 0) continue;
+    outSum.set(e.from, (outSum.get(e.from) ?? 0) + w);
+    if (!inRegion.has(e.to)) continue;
+    const l = out2.get(e.from);
+    if (l) l.push({ to: e.to, weight: w });
+    else out2.set(e.from, [{ to: e.to, weight: w }]);
+  }
+  const boundaryEdges = store2.inEdgesForMany(regionIds).filter((e) => allowedTypes.has(e.type) && !inRegion.has(e.from) && (EDGE_WEIGHT[e.type] ?? 1) > 0);
+  const boundarySources = [...new Set(boundaryEdges.map((e) => e.from))];
+  if (boundarySources.length > cap) return null;
+  const boundaryRanks = store2.ranksForMany(boundarySources);
+  const boundaryOutSum = /* @__PURE__ */ new Map();
+  for (const e of store2.outEdgesForMany(boundarySources)) {
+    if (!allowedTypes.has(e.type)) continue;
+    const w = EDGE_WEIGHT[e.type] ?? 1;
+    if (w > 0) boundaryOutSum.set(e.from, (boundaryOutSum.get(e.from) ?? 0) + w);
+  }
+  const boundaryInflow = /* @__PURE__ */ new Map();
+  for (const e of boundaryEdges) {
+    const r = boundaryRanks.get(e.from);
+    const os2 = boundaryOutSum.get(e.from);
+    if (r === void 0 || !os2) continue;
+    const w = EDGE_WEIGHT[e.type] ?? 1;
+    boundaryInflow.set(e.to, (boundaryInflow.get(e.to) ?? 0) + r * w / os2);
+  }
+  const globalDangling = Number(store2.getMeta("danglingRankShare") ?? 0);
+  let regionDangling = 0;
+  for (const id of regionIds) {
+    if ((outSum.get(id) ?? 0) <= 0) regionDangling += rank0.get(id) ?? 0;
+  }
+  const result = pagerankLocal({
+    regionIds,
+    rank0,
+    out: out2,
+    outSum,
+    boundaryInflow,
+    globalN: liveN,
+    externalDanglingRank: Math.max(0, globalDangling - regionDangling),
+    damping: 0.85,
+    tolerance: 1e-6,
+    maxIterations: 100
+  });
+  let pageRankWritten = 0;
+  store2.transaction(() => {
+    for (const [id, score2] of result.scores) {
+      if (Math.abs(score2 - (rank0.get(id) ?? 0)) < 1e-9) continue;
+      store2.setPageRank(id, score2);
+      pageRankWritten++;
+    }
+  });
+  const sweep = store2.landmarkSweepRows();
+  const candidates = /* @__PURE__ */ new Map();
+  for (const row of sweep) {
+    if (row.label === "Pattern" || row.label === "RootCause") {
+      candidates.set(row.id, result.scores.get(row.id) ?? row.pageRank);
+    }
+  }
+  const want = markLandmarks(candidates, 0.1);
+  for (const row of sweep) if (row.memoryTier === "persistent") want.add(row.id);
+  let landmarkFlips = 0;
+  store2.transaction(() => {
+    for (const row of sweep) {
+      if (row.extractionSource === "bko-inferred") continue;
+      const should = want.has(row.id);
+      if (row.isLandmark === should) continue;
+      store2.setLandmark(row.id, should);
+      landmarkFlips++;
+    }
+  });
+  return {
+    scoredNodes: regionIds.length,
+    iterations: result.iterations,
+    converged: result.converged,
+    landmarks: want.size,
+    communities: 0,
+    // deferred to the full backstop — see mode docs
+    motifsPromoted: 0,
+    techniques: 0,
+    antipatterns: 0,
+    pageRankWritten,
+    landmarkFlips,
+    mode: "incremental",
+    regionSize: regionIds.length,
+    durationMs: Date.now() - started
+  };
+}
+function runFullRescore(store2) {
   const started = Date.now();
   const allowedTypes = new Set(pagerankEdgeTypes());
   const nodeIds = [];
@@ -26420,10 +26757,12 @@ function runGraphRescore(store2) {
     maxIterations: 100
   });
   const scored = result.scores.size;
+  let pageRankWritten = 0;
   store2.transaction(() => {
     for (const [id, score2] of result.scores) {
       if (Math.abs(score2 - (meta3.get(id)?.pageRank ?? 0)) < 1e-9) continue;
       store2.setPageRank(id, score2);
+      pageRankWritten++;
     }
   });
   const landmarkCandidates = /* @__PURE__ */ new Map();
@@ -26438,11 +26777,13 @@ function runGraphRescore(store2) {
   for (const id of nodeIds) {
     if (meta3.get(id)?.memoryTier === "persistent") allLandmarks.add(id);
   }
+  let landmarkFlips = 0;
   store2.transaction(() => {
     for (const id of nodeIds) {
       const want = allLandmarks.has(id);
       if ((meta3.get(id)?.isLandmark ?? false) === want) continue;
       store2.setLandmark(id, want);
+      landmarkFlips++;
     }
   });
   const MOTIF_LABELS = /* @__PURE__ */ new Set(["Pattern", "Technique", "AntiPattern"]);
@@ -26486,6 +26827,12 @@ function runGraphRescore(store2) {
     motifsPromoted: motifs.promoted,
     techniques: motifs.techniques,
     antipatterns: motifs.antipatterns,
+    pageRankWritten,
+    landmarkFlips,
+    mode: "full",
+    regionSize: 0,
+    startedAt: started,
+    danglingRank: result.danglingRank,
     durationMs: Date.now() - started
   };
 }
@@ -26523,6 +26870,10 @@ function runNightlyPipeline(store2) {
     skillsInduced: 0,
     // skills are cloud-induced now (see above)
     skillsRefreshed: 0,
+    pageRankWritten: rescore.pageRankWritten,
+    landmarkFlips: rescore.landmarkFlips,
+    mode: rescore.mode,
+    regionSize: rescore.regionSize,
     designResolved: semantic.designResolved,
     revisitsCleared: semantic.revisitsCleared,
     fixCandidatesSettled: semantic.fixCandidatesSettled,