@inerrata-corporation/errata 2.0.22-dev.4660 → 2.0.22-dev.4669

package/consolidate-worker.mjs

@@ -16825,6 +16825,19 @@ import { parentPort } from "node:worker_threads";
 init_src2();
 init_src();
 
+// ../../packages/local-graph/src/wm-calibration.ts
+var WM_CALIBRATION_KEYS = [
+  "shownCount",
+  "evictedCount",
+  "reinforceShownCount",
+  "reinforceRecentCount",
+  "reinforceEvictedCount",
+  "reinforceUnshownCount",
+  "reinforceUnshownQueryOnlyCount"
+];
+var WM_COUNTED_PREDICATE = WM_CALIBRATION_KEYS.map((k) => `json_type(attrs_json, '$.${k}') IS NOT NULL`).join(" OR ");
+var wmCounterSql = (k) => `CASE WHEN json_type(attrs_json, '$.${k}') IN ('integer', 'real') THEN json_extract(attrs_json, '$.${k}') END`;
+
 // ../../packages/local-graph/src/history-cache-floor.ts
 var HISTORY_CACHE_FLOOR_KEY = "history-cache-withdrawal-floor-3";
 function installHistoryCacheFloor(db) {
@@ -17575,7 +17588,13 @@ var DEMAND_HOT = Math.log1p(10);
 var DEMAND_WARM = Math.log1p(5);
 
 // ../../packages/local-graph/src/node-select.ts
-var SELECT_INDEXES = ["nodes_live_local_community", "nodes_live_fold_candidate"];
+var SELECT_INDEXES = [
+  "nodes_live_local_community",
+  "nodes_live_fold_candidate",
+  "nodes_live_resolved",
+  "nodes_live_fix_candidate",
+  "nodes_live_anchor_hint"
+];
 var EMBEDDING_DIM_SQL = "(CASE WHEN length(embedding_blob) >= 4 THEN length(embedding_blob) / 4 ELSE COALESCE(json_array_length(embedding_json), 0) END)";
 var KEY = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/;
 var COLUMNS = /* @__PURE__ */ new Set([
@@ -17602,7 +17621,7 @@ function column(c) {
 function compileNodeWhere(q) {
   if (q.labels.length === 0) throw new Error("selectNodes: no labels");
   const params = [...q.labels];
-  const byId = (q.where ?? []).some((w) => "idIn" in w);
+  const byId = (q.where ?? []).some((w) => "idIn" in w || "idPrefix" in w && w.idPrefix.length > 0);
   const unindexed = byId ? "+" : "";
   const conds = [`${unindexed}label IN (${q.labels.map(() => "?").join(", ")})`];
   if (!q.includeClosed) conds.push(`${unindexed}valid_to IS NULL`);
@@ -17612,6 +17631,11 @@ function compileNodeWhere(q) {
     } else if ("idPrefix" in w) {
       conds.push("substr(id, 1, ?) = ?");
       params.push(w.idPrefix.length, w.idPrefix);
+      if (w.idPrefix.length > 0) {
+        const last = w.idPrefix.charCodeAt(w.idPrefix.length - 1);
+        conds.push("id >= ? AND id < ?");
+        params.push(w.idPrefix, w.idPrefix.slice(0, -1) + String.fromCharCode(last + 1));
+      }
     } else if ("idIn" in w) {
       if (w.idIn.length === 0) conds.push("0");
       else {
@@ -17893,7 +17917,16 @@ CREATE INDEX IF NOT EXISTS nodes_live_local_community ON nodes(label, valid_to,
 -- Problems parked for the fold judge (read every settle boundary): ~1 in 5 open
 -- Problems; without it every live Problem was read to find them (56 MB).
 CREATE INDEX IF NOT EXISTS nodes_live_fold_candidate ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_type(attrs_json, '$.foldCandidate') IS NOT NULL;
+-- The semantic-maintenance sweeps' own filters (closed, asked, hinted): each read
+-- every Problem row (~30 MB on a 1.1 GB store) for the few hundred that match,
+-- several times a run, and a run follows most writes (2026-10-20).
+CREATE INDEX IF NOT EXISTS nodes_live_resolved ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.resolvedAt') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_live_fix_candidate ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_type(attrs_json, '$.fixCandidateAt') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_live_anchor_hint ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.anchorHint') IS NOT NULL;
 CREATE INDEX IF NOT EXISTS nodes_session_evidence ON nodes(id) WHERE ${SESSION_EVIDENCE_PREDICATE};
+-- Rows carrying a calibration counter, any version: the logical nodes wm
+-- calibration can count (~3k), found without reading every citable row.
+CREATE INDEX IF NOT EXISTS nodes_wm_counted ON nodes(logical_id, version, valid_to, label, ${WM_CALIBRATION_KEYS.map(wmCounterSql).join(", ")}) WHERE ${WM_COUNTED_PREDICATE};
 CREATE INDEX IF NOT EXISTS edges_session_evidence ON edges(id) WHERE ${SESSION_EVIDENCE_PREDICATE};
 -- Covering + partial index for labelFingerprint over the instance labels: the
 -- live-push probe runs it per workspace on a timer, and each hit used to read
@@ -18112,6 +18145,12 @@ var SqliteGraphStore = class {
       `),
       getNode: this.db.prepare("SELECT * FROM nodes WHERE id = ?"),
       labelOf: this.db.prepare("SELECT label FROM nodes WHERE id = ?"),
+      nodeContent: this.db.prepare(
+        "SELECT label, description, extraction_confidence, extraction_source, stability, valid_to, attrs_json FROM nodes WHERE id = ?"
+      ),
+      edgeContent: this.db.prepare(
+        "SELECT confidence, valid_to, attrs_json FROM edges WHERE from_id = ? AND type = ? AND to_id = ?"
+      ),
       // Single-column fast paths for the nightly pass — writing 100k pageRank
       // values through the 18-column COALESCE updateNode took ~30s; these are ~10x
       // cheaper (one bound column, no COALESCE evaluation per row).
@@ -18323,6 +18362,27 @@ var SqliteGraphStore = class {
         ORDER BY label, created_at, rowid`
     ).all(label);
   }
+  wmCalibrationRows(labels) {
+    const counted = this.db.prepare(
+      `SELECT rowid AS rid, logical_id, version, valid_to, label, ${WM_CALIBRATION_KEYS.map((k, i) => `${wmCounterSql(k)} AS c${i}`).join(", ")}
+         FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE}`
+    ).all();
+    const others = this.db.prepare(
+      `SELECT rowid AS rid, logical_id, version, valid_to, label FROM nodes WHERE rowid IN (
+         SELECT n.rowid FROM nodes AS n INDEXED BY nodes_logical
+          WHERE n.logical_id IN (SELECT logical_id FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE})
+         EXCEPT SELECT rowid FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE})`
+    ).all();
+    const order = new Map(labels.map((l, i) => [l, i]));
+    return [...counted, ...others].filter((r) => order.has(r.label)).sort((a, b) => order.get(a.label) - order.get(b.label) || a.rid - b.rid).map((r) => {
+      const attrs = {};
+      WM_CALIBRATION_KEYS.forEach((k, i) => {
+        const v = r[`c${i}`];
+        if (typeof v === "number") attrs[k] = v;
+      });
+      return { logicalId: r.logical_id, version: Number(r.version), validTo: r.valid_to ?? null, attrs };
+    });
+  }
   liveCommentsAttachedTo(name) {
     return this.db.prepare(
       `SELECT json_extract(attrs_json, '$.kind') AS kind, json_extract(attrs_json, '$.text') AS text, description FROM nodes INDEXED BY nodes_live_attached_to
@@ -18462,6 +18522,19 @@ var SqliteGraphStore = class {
       attrs_json: JSON.stringify(node.attrs ?? {})
     });
   }
+  /** mergeNode, unless the live row already holds this content. Content is what
+   *  the columns a merge rewrites from the producer (label, description, attrs,
+   *  confidence, stability);
+   *  rank, community, landmark, surprise, hits, tier and the vector belong to
+   *  the passes that compute them, and a skipped write leaves them as they are
+   *  where a merge would have reset them to the producer's defaults. Returns
+   *  whether it wrote. */
+  mergeNodeIfChanged(node) {
+    const row = this.stmts.nodeContent.get(node.id);
+    if (row && row.valid_to === null && row.label === node.label && row.description === node.description && row.extraction_confidence === node.extractionConfidence && row.stability === node.stability && row.attrs_json === JSON.stringify(node.attrs ?? {})) return false;
+    this.mergeNode(node);
+    return true;
+  }
   updateNode(id, patch) {
     const hasEmbedding = patch.embedding !== void 0 && patch.embedding.length > 0;
     this.stmts.updateNode.run({
@@ -18567,6 +18640,21 @@ var SqliteGraphStore = class {
       attrs_json: JSON.stringify(edge.attrs ?? {})
     });
   }
+  /** mergeEdge, unless the live edge already holds this content: same attrs, and
+   *  a confidence the upsert's MAX would keep. Its navigation posteriors and
+   *  last-seen stamp stay as they are where a merge would have reset them. The
+   *  ontology gate runs first either way, so refusals are recorded as before.
+   *  Returns whether it wrote (or refused). */
+  mergeEdgeIfChanged(edge) {
+    if (!this.edgeRuleViolation(edge)) {
+      const row = this.stmts.edgeContent.get(edge.from, edge.type, edge.to);
+      if (row && row.valid_to === null && row.confidence >= edge.confidence && row.attrs_json === JSON.stringify(edge.attrs ?? {})) {
+        return false;
+      }
+    }
+    this.mergeEdge(edge);
+    return true;
+  }
   /** EDGE_RULES check against the stored endpoints' labels, with the LOCAL
    *  overlay consulted first. Returns the reason string on a documented-
    *  forbidden combination, else null. Point lookups on the id PK — negligible

package/errata.mjs

@@ -18851,6 +18851,87 @@ var init_src2 = __esm({
   }
 });
 
+// ../../packages/local-graph/src/wm-calibration.ts
+function wmCalibrationCells(store) {
+  const cells = {
+    calibrationSchema: WM_CALIBRATION_SCHEMA,
+    shownNodes: 0,
+    shownImpressions: 0,
+    evictedNodes: 0,
+    evictedImpressions: 0,
+    reinforceShown: 0,
+    reinforceRecent: 0,
+    reinforceEvicted: 0,
+    reinforceUnshown: 0,
+    reinforceUnshownQueryOnly: 0,
+    reinforcedNodes: 0,
+    reinforcedShownNodes: 0
+  };
+  const newest = /* @__PURE__ */ new Map();
+  const rows = store.wmCalibrationRows?.(WM_CALIBRATION_LABELS) ?? (function* () {
+    for (const label of WM_CALIBRATION_LABELS) {
+      yield* store.selectNodes({ labels: [label], attrs: WM_CALIBRATION_KEYS, includeClosed: true });
+    }
+  })();
+  for (const n of rows) {
+    const live3 = n.validTo === null;
+    const prev = newest.get(n.logicalId);
+    if (prev && (prev.live || !live3 && prev.version >= n.version)) continue;
+    newest.set(n.logicalId, { version: n.version, live: live3, attrs: n.attrs });
+  }
+  for (const { attrs } of newest.values()) {
+    const shown = num(attrs["shownCount"]);
+    const evicted = num(attrs["evictedCount"]);
+    if (shown > 0) {
+      cells.shownNodes++;
+      cells.shownImpressions += shown;
+    }
+    if (evicted > 0) {
+      cells.evictedNodes++;
+      cells.evictedImpressions += evicted;
+    }
+    const rs = num(attrs["reinforceShownCount"]);
+    const rr = num(attrs["reinforceRecentCount"]);
+    const re = num(attrs["reinforceEvictedCount"]);
+    const ru = num(attrs["reinforceUnshownCount"]);
+    cells.reinforceShown += rs;
+    cells.reinforceRecent += rr;
+    cells.reinforceEvicted += re;
+    cells.reinforceUnshown += ru;
+    cells.reinforceUnshownQueryOnly += num(attrs["reinforceUnshownQueryOnlyCount"]);
+    if (rs + rr + re + ru > 0) cells.reinforcedNodes++;
+    if (rs > 0) cells.reinforcedShownNodes++;
+  }
+  return cells;
+}
+var WM_CALIBRATION_LABELS, WM_CALIBRATION_SCHEMA, num, WM_CALIBRATION_KEYS, WM_COUNTED_PREDICATE, wmCounterSql;
+var init_wm_calibration = __esm({
+  "../../packages/local-graph/src/wm-calibration.ts"() {
+    "use strict";
+    WM_CALIBRATION_LABELS = [
+      "Problem",
+      "Solution",
+      "RootCause",
+      "Pattern",
+      "Technique",
+      "AntiPattern"
+    ];
+    WM_CALIBRATION_SCHEMA = 2;
+    num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+    WM_CALIBRATION_KEYS = [
+      "shownCount",
+      "evictedCount",
+      "reinforceShownCount",
+      "reinforceRecentCount",
+      "reinforceEvictedCount",
+      "reinforceUnshownCount",
+      "reinforceUnshownQueryOnlyCount"
+    ];
+    WM_COUNTED_PREDICATE = WM_CALIBRATION_KEYS.map((k) => `json_type(attrs_json, '$.${k}') IS NOT NULL`).join(" OR ");
+    wmCounterSql = (k) => `CASE WHEN json_type(attrs_json, '$.${k}') IN ('integer', 'real') THEN json_extract(attrs_json, '$.${k}') END`;
+  }
+});
+
 // ../../packages/local-graph/src/history-cache-floor.ts
 function installHistoryCacheFloor(db) {
   const key = HISTORY_CACHE_FLOOR_KEY;
@@ -20398,7 +20479,7 @@ function column(c) {
 function compileNodeWhere(q) {
   if (q.labels.length === 0) throw new Error("selectNodes: no labels");
   const params = [...q.labels];
-  const byId = (q.where ?? []).some((w) => "idIn" in w);
+  const byId = (q.where ?? []).some((w) => "idIn" in w || "idPrefix" in w && w.idPrefix.length > 0);
   const unindexed = byId ? "+" : "";
   const conds = [`${unindexed}label IN (${q.labels.map(() => "?").join(", ")})`];
   if (!q.includeClosed) conds.push(`${unindexed}valid_to IS NULL`);
@@ -20408,6 +20489,11 @@ function compileNodeWhere(q) {
     } else if ("idPrefix" in w) {
       conds.push("substr(id, 1, ?) = ?");
       params.push(w.idPrefix.length, w.idPrefix);
+      if (w.idPrefix.length > 0) {
+        const last = w.idPrefix.charCodeAt(w.idPrefix.length - 1);
+        conds.push("id >= ? AND id < ?");
+        params.push(w.idPrefix, w.idPrefix.slice(0, -1) + String.fromCharCode(last + 1));
+      }
     } else if ("idIn" in w) {
       if (w.idIn.length === 0) conds.push("0");
       else {
@@ -20530,7 +20616,13 @@ var SELECT_INDEXES, EMBEDDING_DIM_SQL, KEY, COLUMNS;
 var init_node_select = __esm({
   "../../packages/local-graph/src/node-select.ts"() {
     "use strict";
-    SELECT_INDEXES = ["nodes_live_local_community", "nodes_live_fold_candidate"];
+    SELECT_INDEXES = [
+      "nodes_live_local_community",
+      "nodes_live_fold_candidate",
+      "nodes_live_resolved",
+      "nodes_live_fix_candidate",
+      "nodes_live_anchor_hint"
+    ];
     EMBEDDING_DIM_SQL = "(CASE WHEN length(embedding_blob) >= 4 THEN length(embedding_blob) / 4 ELSE COALESCE(json_array_length(embedding_json), 0) END)";
     KEY = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/;
     COLUMNS = /* @__PURE__ */ new Set([
@@ -20649,6 +20741,7 @@ var init_store = __esm({
     "use strict";
     init_src2();
     init_src();
+    init_wm_calibration();
     init_history_cache_floor();
     init_session_evidence();
     init_edit_placeholder_retirement();
@@ -20801,7 +20894,16 @@ CREATE INDEX IF NOT EXISTS nodes_live_local_community ON nodes(label, valid_to,
 -- Problems parked for the fold judge (read every settle boundary): ~1 in 5 open
 -- Problems; without it every live Problem was read to find them (56 MB).
 CREATE INDEX IF NOT EXISTS nodes_live_fold_candidate ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_type(attrs_json, '$.foldCandidate') IS NOT NULL;
+-- The semantic-maintenance sweeps' own filters (closed, asked, hinted): each read
+-- every Problem row (~30 MB on a 1.1 GB store) for the few hundred that match,
+-- several times a run, and a run follows most writes (2026-10-20).
+CREATE INDEX IF NOT EXISTS nodes_live_resolved ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.resolvedAt') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_live_fix_candidate ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_type(attrs_json, '$.fixCandidateAt') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_live_anchor_hint ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.anchorHint') IS NOT NULL;
 CREATE INDEX IF NOT EXISTS nodes_session_evidence ON nodes(id) WHERE ${SESSION_EVIDENCE_PREDICATE};
+-- Rows carrying a calibration counter, any version: the logical nodes wm
+-- calibration can count (~3k), found without reading every citable row.
+CREATE INDEX IF NOT EXISTS nodes_wm_counted ON nodes(logical_id, version, valid_to, label, ${WM_CALIBRATION_KEYS.map(wmCounterSql).join(", ")}) WHERE ${WM_COUNTED_PREDICATE};
 CREATE INDEX IF NOT EXISTS edges_session_evidence ON edges(id) WHERE ${SESSION_EVIDENCE_PREDICATE};
 -- Covering + partial index for labelFingerprint over the instance labels: the
 -- live-push probe runs it per workspace on a timer, and each hit used to read
@@ -20963,6 +21065,12 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
       `),
           getNode: this.db.prepare("SELECT * FROM nodes WHERE id = ?"),
           labelOf: this.db.prepare("SELECT label FROM nodes WHERE id = ?"),
+          nodeContent: this.db.prepare(
+            "SELECT label, description, extraction_confidence, extraction_source, stability, valid_to, attrs_json FROM nodes WHERE id = ?"
+          ),
+          edgeContent: this.db.prepare(
+            "SELECT confidence, valid_to, attrs_json FROM edges WHERE from_id = ? AND type = ? AND to_id = ?"
+          ),
           // Single-column fast paths for the nightly pass — writing 100k pageRank
           // values through the 18-column COALESCE updateNode took ~30s; these are ~10x
           // cheaper (one bound column, no COALESCE evaluation per row).
@@ -21174,6 +21282,27 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
         ORDER BY label, created_at, rowid`
         ).all(label);
       }
+      wmCalibrationRows(labels) {
+        const counted = this.db.prepare(
+          `SELECT rowid AS rid, logical_id, version, valid_to, label, ${WM_CALIBRATION_KEYS.map((k, i2) => `${wmCounterSql(k)} AS c${i2}`).join(", ")}
+         FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE}`
+        ).all();
+        const others = this.db.prepare(
+          `SELECT rowid AS rid, logical_id, version, valid_to, label FROM nodes WHERE rowid IN (
+         SELECT n.rowid FROM nodes AS n INDEXED BY nodes_logical
+          WHERE n.logical_id IN (SELECT logical_id FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE})
+         EXCEPT SELECT rowid FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE})`
+        ).all();
+        const order = new Map(labels.map((l, i2) => [l, i2]));
+        return [...counted, ...others].filter((r) => order.has(r.label)).sort((a, b) => order.get(a.label) - order.get(b.label) || a.rid - b.rid).map((r) => {
+          const attrs = {};
+          WM_CALIBRATION_KEYS.forEach((k, i2) => {
+            const v = r[`c${i2}`];
+            if (typeof v === "number") attrs[k] = v;
+          });
+          return { logicalId: r.logical_id, version: Number(r.version), validTo: r.valid_to ?? null, attrs };
+        });
+      }
       liveCommentsAttachedTo(name2) {
         return this.db.prepare(
           `SELECT json_extract(attrs_json, '$.kind') AS kind, json_extract(attrs_json, '$.text') AS text, description FROM nodes INDEXED BY nodes_live_attached_to
@@ -21313,6 +21442,19 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
           attrs_json: JSON.stringify(node2.attrs ?? {})
         });
       }
+      /** mergeNode, unless the live row already holds this content. Content is what
+       *  the columns a merge rewrites from the producer (label, description, attrs,
+       *  confidence, stability);
+       *  rank, community, landmark, surprise, hits, tier and the vector belong to
+       *  the passes that compute them, and a skipped write leaves them as they are
+       *  where a merge would have reset them to the producer's defaults. Returns
+       *  whether it wrote. */
+      mergeNodeIfChanged(node2) {
+        const row = this.stmts.nodeContent.get(node2.id);
+        if (row && row.valid_to === null && row.label === node2.label && row.description === node2.description && row.extraction_confidence === node2.extractionConfidence && row.stability === node2.stability && row.attrs_json === JSON.stringify(node2.attrs ?? {})) return false;
+        this.mergeNode(node2);
+        return true;
+      }
       updateNode(id, patch) {
         const hasEmbedding = patch.embedding !== void 0 && patch.embedding.length > 0;
         this.stmts.updateNode.run({
@@ -21418,6 +21560,21 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
           attrs_json: JSON.stringify(edge2.attrs ?? {})
         });
       }
+      /** mergeEdge, unless the live edge already holds this content: same attrs, and
+       *  a confidence the upsert's MAX would keep. Its navigation posteriors and
+       *  last-seen stamp stay as they are where a merge would have reset them. The
+       *  ontology gate runs first either way, so refusals are recorded as before.
+       *  Returns whether it wrote (or refused). */
+      mergeEdgeIfChanged(edge2) {
+        if (!this.edgeRuleViolation(edge2)) {
+          const row = this.stmts.edgeContent.get(edge2.from, edge2.type, edge2.to);
+          if (row && row.valid_to === null && row.confidence >= edge2.confidence && row.attrs_json === JSON.stringify(edge2.attrs ?? {})) {
+            return false;
+          }
+        }
+        this.mergeEdge(edge2);
+        return true;
+      }
       /** EDGE_RULES check against the stored endpoints' labels, with the LOCAL
        *  overlay consulted first. Returns the reason string on a documented-
        *  forbidden combination, else null. Point lookups on the id PK — negligible
@@ -24534,7 +24691,8 @@ function upgradeAnchorHints(store, workspaceId2, ts) {
   const hinted = store.selectNodes({
     labels: ["Problem"],
     attrs: ["resolvedAt", "anchorHint"],
-    where: [{ attr: "anchorHint", notNullish: true }]
+    where: [{ attr: "anchorHint", notNullish: true }],
+    indexedBy: "nodes_live_anchor_hint"
   });
   for (const row of hinted) {
     if (row.attrs["resolvedAt"]) continue;
@@ -24617,7 +24775,8 @@ function reopenAutoClosedProblems(store, t) {
   const closed = store.selectNodes({
     labels: ["Problem"],
     attrs: ["resolvedAt", "resolvedAs", "mergedInto", "resolutionWitnessed", "retiredEditPlaceholder", "resolutionSuspect"],
-    where: [{ attr: "resolvedAt", notNullish: true }, { attr: "resolvedAs", nullish: true }, { attr: "mergedInto", absent: true }]
+    where: [{ attr: "resolvedAt", notNullish: true }, { attr: "resolvedAs", nullish: true }, { attr: "mergedInto", absent: true }],
+    indexedBy: "nodes_live_resolved"
   });
   for (const p of closed) {
     if (p.attrs["resolvedAt"] == null) continue;
@@ -24735,7 +24894,7 @@ function markFixCandidates(store, t) {
 }
 function clearSettledFixCandidates(store, t) {
   const report = { answered: 0, ignored: 0, unsubstantiated: 0, standing: 0 };
-  const asked = store.selectNodes({ labels: ["Problem"], where: [{ attr: "fixCandidateAt", present: true }] });
+  const asked = store.selectNodes({ labels: ["Problem"], where: [{ attr: "fixCandidateAt", present: true }], indexedBy: "nodes_live_fix_candidate" });
   for (const row of asked) {
     const p = store.getNode(row.id);
     if (!p) continue;
@@ -27419,82 +27578,6 @@ var init_mechanism_liveness = __esm({
   }
 });
 
-// ../../packages/local-graph/src/wm-calibration.ts
-function wmCalibrationCells(store) {
-  const cells = {
-    calibrationSchema: WM_CALIBRATION_SCHEMA,
-    shownNodes: 0,
-    shownImpressions: 0,
-    evictedNodes: 0,
-    evictedImpressions: 0,
-    reinforceShown: 0,
-    reinforceRecent: 0,
-    reinforceEvicted: 0,
-    reinforceUnshown: 0,
-    reinforceUnshownQueryOnly: 0,
-    reinforcedNodes: 0,
-    reinforcedShownNodes: 0
-  };
-  const newest = /* @__PURE__ */ new Map();
-  for (const label of WM_CALIBRATION_LABELS) {
-    for (const n of store.selectNodes({ labels: [label], attrs: WM_CALIBRATION_KEYS, includeClosed: true })) {
-      const live3 = n.validTo === null;
-      const prev = newest.get(n.logicalId);
-      if (prev && (prev.live || !live3 && prev.version >= n.version)) continue;
-      newest.set(n.logicalId, { version: n.version, live: live3, attrs: n.attrs });
-    }
-  }
-  for (const { attrs } of newest.values()) {
-    const shown = num(attrs["shownCount"]);
-    const evicted = num(attrs["evictedCount"]);
-    if (shown > 0) {
-      cells.shownNodes++;
-      cells.shownImpressions += shown;
-    }
-    if (evicted > 0) {
-      cells.evictedNodes++;
-      cells.evictedImpressions += evicted;
-    }
-    const rs = num(attrs["reinforceShownCount"]);
-    const rr = num(attrs["reinforceRecentCount"]);
-    const re = num(attrs["reinforceEvictedCount"]);
-    const ru = num(attrs["reinforceUnshownCount"]);
-    cells.reinforceShown += rs;
-    cells.reinforceRecent += rr;
-    cells.reinforceEvicted += re;
-    cells.reinforceUnshown += ru;
-    cells.reinforceUnshownQueryOnly += num(attrs["reinforceUnshownQueryOnlyCount"]);
-    if (rs + rr + re + ru > 0) cells.reinforcedNodes++;
-    if (rs > 0) cells.reinforcedShownNodes++;
-  }
-  return cells;
-}
-var WM_CALIBRATION_LABELS, WM_CALIBRATION_SCHEMA, num, WM_CALIBRATION_KEYS;
-var init_wm_calibration = __esm({
-  "../../packages/local-graph/src/wm-calibration.ts"() {
-    "use strict";
-    WM_CALIBRATION_LABELS = [
-      "Problem",
-      "Solution",
-      "RootCause",
-      "Pattern",
-      "Technique",
-      "AntiPattern"
-    ];
-    WM_CALIBRATION_SCHEMA = 2;
-    num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
-    WM_CALIBRATION_KEYS = [
-      "shownCount",
-      "evictedCount",
-      "reinforceShownCount",
-      "reinforceRecentCount",
-      "reinforceEvictedCount",
-      "reinforceUnshownCount",
-      "reinforceUnshownQueryOnlyCount"
-    ];
-  }
-});
-
 // ../../packages/local-graph/src/index.ts
 var src_exports2 = {};
 __export(src_exports2, {
@@ -27541,8 +27624,10 @@ __export(src_exports2, {
   STALL_MIN_RUNS: () => STALL_MIN_RUNS,
   STALL_MIN_SPAN_MS: () => STALL_MIN_SPAN_MS,
   SqliteGraphStore: () => SqliteGraphStore,
+  WM_CALIBRATION_KEYS: () => WM_CALIBRATION_KEYS,
   WM_CALIBRATION_LABELS: () => WM_CALIBRATION_LABELS,
   WM_CALIBRATION_SCHEMA: () => WM_CALIBRATION_SCHEMA,
+  WM_COUNTED_PREDICATE: () => WM_COUNTED_PREDICATE,
   WORKSPACE_SCAN_CAP: () => WORKSPACE_SCAN_CAP,
   addDependency: () => addDependency,
   aggregateClaimConfidence: () => aggregateClaimConfidence,
@@ -27689,7 +27774,8 @@ __export(src_exports2, {
   upgradeAnchorHints: () => upgradeAnchorHints,
   upgradeAnchorHintsForFile: () => upgradeAnchorHintsForFile,
   walk: () => walk,
-  wmCalibrationCells: () => wmCalibrationCells
+  wmCalibrationCells: () => wmCalibrationCells,
+  wmCounterSql: () => wmCounterSql
 });
 var init_src5 = __esm({
   "../../packages/local-graph/src/index.ts"() {
@@ -38975,7 +39061,28 @@ async function incrementalReindex(store, rootPath, workspaceId2, changedAbsPaths
       store.closeNode(nid, t);
     }
   });
-  const r = await runIndexer(store, {
+  const seenNodes = /* @__PURE__ */ new Set();
+  const seenEdges = /* @__PURE__ */ new Set();
+  const writeStore = store.mergeNodeIfChanged && store.mergeEdgeIfChanged ? new Proxy(store, {
+    get(target, prop) {
+      if (prop === "mergeNode") {
+        return (n) => {
+          seenNodes.add(n.id);
+          if (n.label === "File" || n.label === "Folder") target.mergeNode(n);
+          else target.mergeNodeIfChanged(n);
+        };
+      }
+      if (prop === "mergeEdge") {
+        return (e) => {
+          seenEdges.add(edgeId(e.from, e.type, e.to));
+          target.mergeEdgeIfChanged(e);
+        };
+      }
+      const v = Reflect.get(target, prop, target);
+      return typeof v === "function" ? v.bind(target) : v;
+    }
+  }) : store;
+  const r = await runIndexer(writeStore, {
     workspaceId: workspaceId2,
     rootPath,
     providers,
@@ -38993,14 +39100,14 @@ async function incrementalReindex(store, rootPath, workspaceId2, changedAbsPaths
       if (typeof rel !== "string" || !changedRelPaths.has(rel)) continue;
       if (versionedAndFile.has(n.label)) {
         ownedLive.push(n.id);
-      } else if (n.label === "Comment" && n.lastUpdatedAt < t) {
+      } else if (n.label === "Comment" && n.lastUpdatedAt < t && !seenNodes.has(n.id)) {
         store.closeNode(n.id, t);
       }
     }
     for (const id of ownedLive) {
       for (const e of store.outEdges(id)) {
         if (e.type === "SUPERSEDED_BY") continue;
-        if (e.lastSeenAt < t) {
+        if (e.lastSeenAt < t && !seenEdges.has(edgeId(e.from, e.type, e.to))) {
           store.closeEdge(e.id, t);
           delta.edgesRemoved++;
         } else if (e.createdAt >= t) {
@@ -87030,7 +87137,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.22-dev.4660" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.22-dev.4669" : "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;

package/generalize-worker.mjs

@@ -15402,6 +15402,19 @@ var LEADING_VERB = new RegExp(String.raw`^\s*(${VERB_WORDS_SOURCE})\s*:`, "i");
 var ANY_VERB_WORD = new RegExp(String.raw`\b(?:${VERB_WORDS_SOURCE})\s*:`, "gi");
 var QUOTED_TAG_OPENER = new RegExp(String.raw`\(\s*(?:(${VERB_WORDS_SOURCE})\s*:|(?=\[))`, "gi");
 
+// ../../packages/local-graph/src/wm-calibration.ts
+var WM_CALIBRATION_KEYS = [
+  "shownCount",
+  "evictedCount",
+  "reinforceShownCount",
+  "reinforceRecentCount",
+  "reinforceEvictedCount",
+  "reinforceUnshownCount",
+  "reinforceUnshownQueryOnlyCount"
+];
+var WM_COUNTED_PREDICATE = WM_CALIBRATION_KEYS.map((k) => `json_type(attrs_json, '$.${k}') IS NOT NULL`).join(" OR ");
+var wmCounterSql = (k) => `CASE WHEN json_type(attrs_json, '$.${k}') IN ('integer', 'real') THEN json_extract(attrs_json, '$.${k}') END`;
+
 // ../../packages/local-graph/src/history-cache-floor.ts
 var HISTORY_CACHE_FLOOR_KEY = "history-cache-withdrawal-floor-3";
 function installHistoryCacheFloor(db) {
@@ -15972,7 +15985,13 @@ var DEMAND_HOT = Math.log1p(10);
 var DEMAND_WARM = Math.log1p(5);
 
 // ../../packages/local-graph/src/node-select.ts
-var SELECT_INDEXES = ["nodes_live_local_community", "nodes_live_fold_candidate"];
+var SELECT_INDEXES = [
+  "nodes_live_local_community",
+  "nodes_live_fold_candidate",
+  "nodes_live_resolved",
+  "nodes_live_fix_candidate",
+  "nodes_live_anchor_hint"
+];
 var EMBEDDING_DIM_SQL = "(CASE WHEN length(embedding_blob) >= 4 THEN length(embedding_blob) / 4 ELSE COALESCE(json_array_length(embedding_json), 0) END)";
 var KEY = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/;
 var COLUMNS = /* @__PURE__ */ new Set([
@@ -15999,7 +16018,7 @@ function column(c) {
 function compileNodeWhere(q) {
   if (q.labels.length === 0) throw new Error("selectNodes: no labels");
   const params = [...q.labels];
-  const byId = (q.where ?? []).some((w) => "idIn" in w);
+  const byId = (q.where ?? []).some((w) => "idIn" in w || "idPrefix" in w && w.idPrefix.length > 0);
   const unindexed = byId ? "+" : "";
   const conds = [`${unindexed}label IN (${q.labels.map(() => "?").join(", ")})`];
   if (!q.includeClosed) conds.push(`${unindexed}valid_to IS NULL`);
@@ -16009,6 +16028,11 @@ function compileNodeWhere(q) {
     } else if ("idPrefix" in w) {
       conds.push("substr(id, 1, ?) = ?");
       params.push(w.idPrefix.length, w.idPrefix);
+      if (w.idPrefix.length > 0) {
+        const last = w.idPrefix.charCodeAt(w.idPrefix.length - 1);
+        conds.push("id >= ? AND id < ?");
+        params.push(w.idPrefix, w.idPrefix.slice(0, -1) + String.fromCharCode(last + 1));
+      }
     } else if ("idIn" in w) {
       if (w.idIn.length === 0) conds.push("0");
       else {
@@ -16290,7 +16314,16 @@ CREATE INDEX IF NOT EXISTS nodes_live_local_community ON nodes(label, valid_to,
 -- Problems parked for the fold judge (read every settle boundary): ~1 in 5 open
 -- Problems; without it every live Problem was read to find them (56 MB).
 CREATE INDEX IF NOT EXISTS nodes_live_fold_candidate ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_type(attrs_json, '$.foldCandidate') IS NOT NULL;
+-- The semantic-maintenance sweeps' own filters (closed, asked, hinted): each read
+-- every Problem row (~30 MB on a 1.1 GB store) for the few hundred that match,
+-- several times a run, and a run follows most writes (2026-10-20).
+CREATE INDEX IF NOT EXISTS nodes_live_resolved ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.resolvedAt') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_live_fix_candidate ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_type(attrs_json, '$.fixCandidateAt') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_live_anchor_hint ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.anchorHint') IS NOT NULL;
 CREATE INDEX IF NOT EXISTS nodes_session_evidence ON nodes(id) WHERE ${SESSION_EVIDENCE_PREDICATE};
+-- Rows carrying a calibration counter, any version: the logical nodes wm
+-- calibration can count (~3k), found without reading every citable row.
+CREATE INDEX IF NOT EXISTS nodes_wm_counted ON nodes(logical_id, version, valid_to, label, ${WM_CALIBRATION_KEYS.map(wmCounterSql).join(", ")}) WHERE ${WM_COUNTED_PREDICATE};
 CREATE INDEX IF NOT EXISTS edges_session_evidence ON edges(id) WHERE ${SESSION_EVIDENCE_PREDICATE};
 -- Covering + partial index for labelFingerprint over the instance labels: the
 -- live-push probe runs it per workspace on a timer, and each hit used to read
@@ -16509,6 +16542,12 @@ var SqliteGraphStore = class {
       `),
       getNode: this.db.prepare("SELECT * FROM nodes WHERE id = ?"),
       labelOf: this.db.prepare("SELECT label FROM nodes WHERE id = ?"),
+      nodeContent: this.db.prepare(
+        "SELECT label, description, extraction_confidence, extraction_source, stability, valid_to, attrs_json FROM nodes WHERE id = ?"
+      ),
+      edgeContent: this.db.prepare(
+        "SELECT confidence, valid_to, attrs_json FROM edges WHERE from_id = ? AND type = ? AND to_id = ?"
+      ),
       // Single-column fast paths for the nightly pass — writing 100k pageRank
       // values through the 18-column COALESCE updateNode took ~30s; these are ~10x
       // cheaper (one bound column, no COALESCE evaluation per row).
@@ -16720,6 +16759,27 @@ var SqliteGraphStore = class {
         ORDER BY label, created_at, rowid`
     ).all(label);
   }
+  wmCalibrationRows(labels) {
+    const counted = this.db.prepare(
+      `SELECT rowid AS rid, logical_id, version, valid_to, label, ${WM_CALIBRATION_KEYS.map((k, i) => `${wmCounterSql(k)} AS c${i}`).join(", ")}
+         FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE}`
+    ).all();
+    const others = this.db.prepare(
+      `SELECT rowid AS rid, logical_id, version, valid_to, label FROM nodes WHERE rowid IN (
+         SELECT n.rowid FROM nodes AS n INDEXED BY nodes_logical
+          WHERE n.logical_id IN (SELECT logical_id FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE})
+         EXCEPT SELECT rowid FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE})`
+    ).all();
+    const order = new Map(labels.map((l, i) => [l, i]));
+    return [...counted, ...others].filter((r) => order.has(r.label)).sort((a, b) => order.get(a.label) - order.get(b.label) || a.rid - b.rid).map((r) => {
+      const attrs = {};
+      WM_CALIBRATION_KEYS.forEach((k, i) => {
+        const v = r[`c${i}`];
+        if (typeof v === "number") attrs[k] = v;
+      });
+      return { logicalId: r.logical_id, version: Number(r.version), validTo: r.valid_to ?? null, attrs };
+    });
+  }
   liveCommentsAttachedTo(name) {
     return this.db.prepare(
       `SELECT json_extract(attrs_json, '$.kind') AS kind, json_extract(attrs_json, '$.text') AS text, description FROM nodes INDEXED BY nodes_live_attached_to
@@ -16859,6 +16919,19 @@ var SqliteGraphStore = class {
       attrs_json: JSON.stringify(node.attrs ?? {})
     });
   }
+  /** mergeNode, unless the live row already holds this content. Content is what
+   *  the columns a merge rewrites from the producer (label, description, attrs,
+   *  confidence, stability);
+   *  rank, community, landmark, surprise, hits, tier and the vector belong to
+   *  the passes that compute them, and a skipped write leaves them as they are
+   *  where a merge would have reset them to the producer's defaults. Returns
+   *  whether it wrote. */
+  mergeNodeIfChanged(node) {
+    const row = this.stmts.nodeContent.get(node.id);
+    if (row && row.valid_to === null && row.label === node.label && row.description === node.description && row.extraction_confidence === node.extractionConfidence && row.stability === node.stability && row.attrs_json === JSON.stringify(node.attrs ?? {})) return false;
+    this.mergeNode(node);
+    return true;
+  }
   updateNode(id, patch) {
     const hasEmbedding = patch.embedding !== void 0 && patch.embedding.length > 0;
     this.stmts.updateNode.run({
@@ -16964,6 +17037,21 @@ var SqliteGraphStore = class {
       attrs_json: JSON.stringify(edge.attrs ?? {})
     });
   }
+  /** mergeEdge, unless the live edge already holds this content: same attrs, and
+   *  a confidence the upsert's MAX would keep. Its navigation posteriors and
+   *  last-seen stamp stay as they are where a merge would have reset them. The
+   *  ontology gate runs first either way, so refusals are recorded as before.
+   *  Returns whether it wrote (or refused). */
+  mergeEdgeIfChanged(edge) {
+    if (!this.edgeRuleViolation(edge)) {
+      const row = this.stmts.edgeContent.get(edge.from, edge.type, edge.to);
+      if (row && row.valid_to === null && row.confidence >= edge.confidence && row.attrs_json === JSON.stringify(edge.attrs ?? {})) {
+        return false;
+      }
+    }
+    this.mergeEdge(edge);
+    return true;
+  }
   /** EDGE_RULES check against the stored endpoints' labels, with the LOCAL
    *  overlay consulted first. Returns the reason string on a documented-
    *  forbidden combination, else null. Point lookups on the id PK — negligible

package/package.json

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

package/pass-worker.mjs

@@ -17629,7 +17629,28 @@ async function incrementalReindex(store2, rootPath, workspaceId, changedAbsPaths
       store2.closeNode(nid, t);
     }
   });
-  const r = await runIndexer(store2, {
+  const seenNodes = /* @__PURE__ */ new Set();
+  const seenEdges = /* @__PURE__ */ new Set();
+  const writeStore = store2.mergeNodeIfChanged && store2.mergeEdgeIfChanged ? new Proxy(store2, {
+    get(target, prop) {
+      if (prop === "mergeNode") {
+        return (n) => {
+          seenNodes.add(n.id);
+          if (n.label === "File" || n.label === "Folder") target.mergeNode(n);
+          else target.mergeNodeIfChanged(n);
+        };
+      }
+      if (prop === "mergeEdge") {
+        return (e) => {
+          seenEdges.add(edgeId(e.from, e.type, e.to));
+          target.mergeEdgeIfChanged(e);
+        };
+      }
+      const v = Reflect.get(target, prop, target);
+      return typeof v === "function" ? v.bind(target) : v;
+    }
+  }) : store2;
+  const r = await runIndexer(writeStore, {
     workspaceId,
     rootPath,
     providers,
@@ -17647,14 +17668,14 @@ async function incrementalReindex(store2, rootPath, workspaceId, changedAbsPaths
       if (typeof rel !== "string" || !changedRelPaths.has(rel)) continue;
       if (versionedAndFile.has(n.label)) {
         ownedLive.push(n.id);
-      } else if (n.label === "Comment" && n.lastUpdatedAt < t) {
+      } else if (n.label === "Comment" && n.lastUpdatedAt < t && !seenNodes.has(n.id)) {
         store2.closeNode(n.id, t);
       }
     }
     for (const id of ownedLive) {
       for (const e of store2.outEdges(id)) {
         if (e.type === "SUPERSEDED_BY") continue;
-        if (e.lastSeenAt < t) {
+        if (e.lastSeenAt < t && !seenEdges.has(edgeId(e.from, e.type, e.to))) {
           store2.closeEdge(e.id, t);
           delta.edgesRemoved++;
         } else if (e.createdAt >= t) {
@@ -25842,6 +25863,81 @@ import { parentPort, workerData } from "node:worker_threads";
 init_src2();
 init_src();
 
+// ../../packages/local-graph/src/wm-calibration.ts
+var WM_CALIBRATION_LABELS = [
+  "Problem",
+  "Solution",
+  "RootCause",
+  "Pattern",
+  "Technique",
+  "AntiPattern"
+];
+var WM_CALIBRATION_SCHEMA = 2;
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var WM_CALIBRATION_KEYS = [
+  "shownCount",
+  "evictedCount",
+  "reinforceShownCount",
+  "reinforceRecentCount",
+  "reinforceEvictedCount",
+  "reinforceUnshownCount",
+  "reinforceUnshownQueryOnlyCount"
+];
+var WM_COUNTED_PREDICATE = WM_CALIBRATION_KEYS.map((k) => `json_type(attrs_json, '$.${k}') IS NOT NULL`).join(" OR ");
+var wmCounterSql = (k) => `CASE WHEN json_type(attrs_json, '$.${k}') IN ('integer', 'real') THEN json_extract(attrs_json, '$.${k}') END`;
+function wmCalibrationCells(store2) {
+  const cells = {
+    calibrationSchema: WM_CALIBRATION_SCHEMA,
+    shownNodes: 0,
+    shownImpressions: 0,
+    evictedNodes: 0,
+    evictedImpressions: 0,
+    reinforceShown: 0,
+    reinforceRecent: 0,
+    reinforceEvicted: 0,
+    reinforceUnshown: 0,
+    reinforceUnshownQueryOnly: 0,
+    reinforcedNodes: 0,
+    reinforcedShownNodes: 0
+  };
+  const newest = /* @__PURE__ */ new Map();
+  const rows = store2.wmCalibrationRows?.(WM_CALIBRATION_LABELS) ?? (function* () {
+    for (const label of WM_CALIBRATION_LABELS) {
+      yield* store2.selectNodes({ labels: [label], attrs: WM_CALIBRATION_KEYS, includeClosed: true });
+    }
+  })();
+  for (const n of rows) {
+    const live = n.validTo === null;
+    const prev = newest.get(n.logicalId);
+    if (prev && (prev.live || !live && prev.version >= n.version)) continue;
+    newest.set(n.logicalId, { version: n.version, live, attrs: n.attrs });
+  }
+  for (const { attrs } of newest.values()) {
+    const shown = num(attrs["shownCount"]);
+    const evicted = num(attrs["evictedCount"]);
+    if (shown > 0) {
+      cells.shownNodes++;
+      cells.shownImpressions += shown;
+    }
+    if (evicted > 0) {
+      cells.evictedNodes++;
+      cells.evictedImpressions += evicted;
+    }
+    const rs = num(attrs["reinforceShownCount"]);
+    const rr = num(attrs["reinforceRecentCount"]);
+    const re = num(attrs["reinforceEvictedCount"]);
+    const ru = num(attrs["reinforceUnshownCount"]);
+    cells.reinforceShown += rs;
+    cells.reinforceRecent += rr;
+    cells.reinforceEvicted += re;
+    cells.reinforceUnshown += ru;
+    cells.reinforceUnshownQueryOnly += num(attrs["reinforceUnshownQueryOnlyCount"]);
+    if (rs + rr + re + ru > 0) cells.reinforcedNodes++;
+    if (rs > 0) cells.reinforcedShownNodes++;
+  }
+  return cells;
+}
+
 // ../../packages/local-graph/src/history-cache-floor.ts
 var HISTORY_CACHE_FLOOR_KEY = "history-cache-withdrawal-floor-3";
 function installHistoryCacheFloor(db) {
@@ -26851,7 +26947,13 @@ function pagerankLocal(input) {
 }
 
 // ../../packages/local-graph/src/node-select.ts
-var SELECT_INDEXES = ["nodes_live_local_community", "nodes_live_fold_candidate"];
+var SELECT_INDEXES = [
+  "nodes_live_local_community",
+  "nodes_live_fold_candidate",
+  "nodes_live_resolved",
+  "nodes_live_fix_candidate",
+  "nodes_live_anchor_hint"
+];
 var EMBEDDING_DIM_SQL = "(CASE WHEN length(embedding_blob) >= 4 THEN length(embedding_blob) / 4 ELSE COALESCE(json_array_length(embedding_json), 0) END)";
 var KEY = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/;
 var COLUMNS = /* @__PURE__ */ new Set([
@@ -26878,7 +26980,7 @@ function column(c) {
 function compileNodeWhere(q) {
   if (q.labels.length === 0) throw new Error("selectNodes: no labels");
   const params = [...q.labels];
-  const byId = (q.where ?? []).some((w) => "idIn" in w);
+  const byId = (q.where ?? []).some((w) => "idIn" in w || "idPrefix" in w && w.idPrefix.length > 0);
   const unindexed = byId ? "+" : "";
   const conds = [`${unindexed}label IN (${q.labels.map(() => "?").join(", ")})`];
   if (!q.includeClosed) conds.push(`${unindexed}valid_to IS NULL`);
@@ -26888,6 +26990,11 @@ function compileNodeWhere(q) {
     } else if ("idPrefix" in w) {
       conds.push("substr(id, 1, ?) = ?");
       params.push(w.idPrefix.length, w.idPrefix);
+      if (w.idPrefix.length > 0) {
+        const last = w.idPrefix.charCodeAt(w.idPrefix.length - 1);
+        conds.push("id >= ? AND id < ?");
+        params.push(w.idPrefix, w.idPrefix.slice(0, -1) + String.fromCharCode(last + 1));
+      }
     } else if ("idIn" in w) {
       if (w.idIn.length === 0) conds.push("0");
       else {
@@ -27169,7 +27276,16 @@ CREATE INDEX IF NOT EXISTS nodes_live_local_community ON nodes(label, valid_to,
 -- Problems parked for the fold judge (read every settle boundary): ~1 in 5 open
 -- Problems; without it every live Problem was read to find them (56 MB).
 CREATE INDEX IF NOT EXISTS nodes_live_fold_candidate ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_type(attrs_json, '$.foldCandidate') IS NOT NULL;
+-- The semantic-maintenance sweeps' own filters (closed, asked, hinted): each read
+-- every Problem row (~30 MB on a 1.1 GB store) for the few hundred that match,
+-- several times a run, and a run follows most writes (2026-10-20).
+CREATE INDEX IF NOT EXISTS nodes_live_resolved ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.resolvedAt') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_live_fix_candidate ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_type(attrs_json, '$.fixCandidateAt') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_live_anchor_hint ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.anchorHint') IS NOT NULL;
 CREATE INDEX IF NOT EXISTS nodes_session_evidence ON nodes(id) WHERE ${SESSION_EVIDENCE_PREDICATE};
+-- Rows carrying a calibration counter, any version: the logical nodes wm
+-- calibration can count (~3k), found without reading every citable row.
+CREATE INDEX IF NOT EXISTS nodes_wm_counted ON nodes(logical_id, version, valid_to, label, ${WM_CALIBRATION_KEYS.map(wmCounterSql).join(", ")}) WHERE ${WM_COUNTED_PREDICATE};
 CREATE INDEX IF NOT EXISTS edges_session_evidence ON edges(id) WHERE ${SESSION_EVIDENCE_PREDICATE};
 -- Covering + partial index for labelFingerprint over the instance labels: the
 -- live-push probe runs it per workspace on a timer, and each hit used to read
@@ -27388,6 +27504,12 @@ var SqliteGraphStore = class {
       `),
       getNode: this.db.prepare("SELECT * FROM nodes WHERE id = ?"),
       labelOf: this.db.prepare("SELECT label FROM nodes WHERE id = ?"),
+      nodeContent: this.db.prepare(
+        "SELECT label, description, extraction_confidence, extraction_source, stability, valid_to, attrs_json FROM nodes WHERE id = ?"
+      ),
+      edgeContent: this.db.prepare(
+        "SELECT confidence, valid_to, attrs_json FROM edges WHERE from_id = ? AND type = ? AND to_id = ?"
+      ),
       // Single-column fast paths for the nightly pass — writing 100k pageRank
       // values through the 18-column COALESCE updateNode took ~30s; these are ~10x
       // cheaper (one bound column, no COALESCE evaluation per row).
@@ -27599,6 +27721,27 @@ var SqliteGraphStore = class {
         ORDER BY label, created_at, rowid`
     ).all(label);
   }
+  wmCalibrationRows(labels) {
+    const counted = this.db.prepare(
+      `SELECT rowid AS rid, logical_id, version, valid_to, label, ${WM_CALIBRATION_KEYS.map((k, i2) => `${wmCounterSql(k)} AS c${i2}`).join(", ")}
+         FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE}`
+    ).all();
+    const others = this.db.prepare(
+      `SELECT rowid AS rid, logical_id, version, valid_to, label FROM nodes WHERE rowid IN (
+         SELECT n.rowid FROM nodes AS n INDEXED BY nodes_logical
+          WHERE n.logical_id IN (SELECT logical_id FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE})
+         EXCEPT SELECT rowid FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE})`
+    ).all();
+    const order = new Map(labels.map((l, i2) => [l, i2]));
+    return [...counted, ...others].filter((r) => order.has(r.label)).sort((a, b) => order.get(a.label) - order.get(b.label) || a.rid - b.rid).map((r) => {
+      const attrs = {};
+      WM_CALIBRATION_KEYS.forEach((k, i2) => {
+        const v = r[`c${i2}`];
+        if (typeof v === "number") attrs[k] = v;
+      });
+      return { logicalId: r.logical_id, version: Number(r.version), validTo: r.valid_to ?? null, attrs };
+    });
+  }
   liveCommentsAttachedTo(name2) {
     return this.db.prepare(
       `SELECT json_extract(attrs_json, '$.kind') AS kind, json_extract(attrs_json, '$.text') AS text, description FROM nodes INDEXED BY nodes_live_attached_to
@@ -27738,6 +27881,19 @@ var SqliteGraphStore = class {
       attrs_json: JSON.stringify(node.attrs ?? {})
     });
   }
+  /** mergeNode, unless the live row already holds this content. Content is what
+   *  the columns a merge rewrites from the producer (label, description, attrs,
+   *  confidence, stability);
+   *  rank, community, landmark, surprise, hits, tier and the vector belong to
+   *  the passes that compute them, and a skipped write leaves them as they are
+   *  where a merge would have reset them to the producer's defaults. Returns
+   *  whether it wrote. */
+  mergeNodeIfChanged(node) {
+    const row = this.stmts.nodeContent.get(node.id);
+    if (row && row.valid_to === null && row.label === node.label && row.description === node.description && row.extraction_confidence === node.extractionConfidence && row.stability === node.stability && row.attrs_json === JSON.stringify(node.attrs ?? {})) return false;
+    this.mergeNode(node);
+    return true;
+  }
   updateNode(id, patch) {
     const hasEmbedding = patch.embedding !== void 0 && patch.embedding.length > 0;
     this.stmts.updateNode.run({
@@ -27843,6 +27999,21 @@ var SqliteGraphStore = class {
       attrs_json: JSON.stringify(edge.attrs ?? {})
     });
   }
+  /** mergeEdge, unless the live edge already holds this content: same attrs, and
+   *  a confidence the upsert's MAX would keep. Its navigation posteriors and
+   *  last-seen stamp stay as they are where a merge would have reset them. The
+   *  ontology gate runs first either way, so refusals are recorded as before.
+   *  Returns whether it wrote (or refused). */
+  mergeEdgeIfChanged(edge) {
+    if (!this.edgeRuleViolation(edge)) {
+      const row = this.stmts.edgeContent.get(edge.from, edge.type, edge.to);
+      if (row && row.valid_to === null && row.confidence >= edge.confidence && row.attrs_json === JSON.stringify(edge.attrs ?? {})) {
+        return false;
+      }
+    }
+    this.mergeEdge(edge);
+    return true;
+  }
   /** EDGE_RULES check against the stored endpoints' labels, with the LOCAL
    *  overlay consulted first. Returns the reason string on a documented-
    *  forbidden combination, else null. Point lookups on the id PK — negligible
@@ -29387,7 +29558,8 @@ function upgradeAnchorHints(store2, workspaceId, ts) {
   const hinted = store2.selectNodes({
     labels: ["Problem"],
     attrs: ["resolvedAt", "anchorHint"],
-    where: [{ attr: "anchorHint", notNullish: true }]
+    where: [{ attr: "anchorHint", notNullish: true }],
+    indexedBy: "nodes_live_anchor_hint"
   });
   for (const row of hinted) {
     if (row.attrs["resolvedAt"]) continue;
@@ -29418,7 +29590,8 @@ function reopenAutoClosedProblems(store2, t) {
   const closed = store2.selectNodes({
     labels: ["Problem"],
     attrs: ["resolvedAt", "resolvedAs", "mergedInto", "resolutionWitnessed", "retiredEditPlaceholder", "resolutionSuspect"],
-    where: [{ attr: "resolvedAt", notNullish: true }, { attr: "resolvedAs", nullish: true }, { attr: "mergedInto", absent: true }]
+    where: [{ attr: "resolvedAt", notNullish: true }, { attr: "resolvedAs", nullish: true }, { attr: "mergedInto", absent: true }],
+    indexedBy: "nodes_live_resolved"
   });
   for (const p of closed) {
     if (p.attrs["resolvedAt"] == null) continue;
@@ -29507,7 +29680,7 @@ function markFixCandidates(store2, t) {
 var FIX_CANDIDATE_ASK_LIMIT = 5;
 function clearSettledFixCandidates(store2, t) {
   const report = { answered: 0, ignored: 0, unsubstantiated: 0, standing: 0 };
-  const asked = store2.selectNodes({ labels: ["Problem"], where: [{ attr: "fixCandidateAt", present: true }] });
+  const asked = store2.selectNodes({ labels: ["Problem"], where: [{ attr: "fixCandidateAt", present: true }], indexedBy: "nodes_live_fix_candidate" });
   for (const row of asked) {
     const p = store2.getNode(row.id);
     if (!p) continue;
@@ -30396,76 +30569,6 @@ function minFractionOf(d) {
   return d.fedIncoming?.minFraction ?? d.fedEdges?.minFraction ?? d.fed?.minFraction ?? 0;
 }
 
-// ../../packages/local-graph/src/wm-calibration.ts
-var WM_CALIBRATION_LABELS = [
-  "Problem",
-  "Solution",
-  "RootCause",
-  "Pattern",
-  "Technique",
-  "AntiPattern"
-];
-var WM_CALIBRATION_SCHEMA = 2;
-var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
-var WM_CALIBRATION_KEYS = [
-  "shownCount",
-  "evictedCount",
-  "reinforceShownCount",
-  "reinforceRecentCount",
-  "reinforceEvictedCount",
-  "reinforceUnshownCount",
-  "reinforceUnshownQueryOnlyCount"
-];
-function wmCalibrationCells(store2) {
-  const cells = {
-    calibrationSchema: WM_CALIBRATION_SCHEMA,
-    shownNodes: 0,
-    shownImpressions: 0,
-    evictedNodes: 0,
-    evictedImpressions: 0,
-    reinforceShown: 0,
-    reinforceRecent: 0,
-    reinforceEvicted: 0,
-    reinforceUnshown: 0,
-    reinforceUnshownQueryOnly: 0,
-    reinforcedNodes: 0,
-    reinforcedShownNodes: 0
-  };
-  const newest = /* @__PURE__ */ new Map();
-  for (const label of WM_CALIBRATION_LABELS) {
-    for (const n of store2.selectNodes({ labels: [label], attrs: WM_CALIBRATION_KEYS, includeClosed: true })) {
-      const live = n.validTo === null;
-      const prev = newest.get(n.logicalId);
-      if (prev && (prev.live || !live && prev.version >= n.version)) continue;
-      newest.set(n.logicalId, { version: n.version, live, attrs: n.attrs });
-    }
-  }
-  for (const { attrs } of newest.values()) {
-    const shown = num(attrs["shownCount"]);
-    const evicted = num(attrs["evictedCount"]);
-    if (shown > 0) {
-      cells.shownNodes++;
-      cells.shownImpressions += shown;
-    }
-    if (evicted > 0) {
-      cells.evictedNodes++;
-      cells.evictedImpressions += evicted;
-    }
-    const rs = num(attrs["reinforceShownCount"]);
-    const rr = num(attrs["reinforceRecentCount"]);
-    const re = num(attrs["reinforceEvictedCount"]);
-    const ru = num(attrs["reinforceUnshownCount"]);
-    cells.reinforceShown += rs;
-    cells.reinforceRecent += rr;
-    cells.reinforceEvicted += re;
-    cells.reinforceUnshown += ru;
-    cells.reinforceUnshownQueryOnly += num(attrs["reinforceUnshownQueryOnlyCount"]);
-    if (rs + rr + re + ru > 0) cells.reinforcedNodes++;
-    if (rs > 0) cells.reinforcedShownNodes++;
-  }
-  return cells;
-}
-
 // ../../packages/generalizer/src/generalizer.ts
 init_src2();
 init_src();

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

@@ -1,6 +1,6 @@
 {
   "name": "errata-context",
-  "version": "2.0.22-dev.4660",
+  "version": "2.0.22-dev.4669",
   "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 @@
-3bcb422706463f9d29ee3751dd1036046ce56211386ec8d38b1cbe53b26ac809  .codex-plugin/plugin.json
+235e69b11fb75b5854bbe0e3e025fdad29c29d8b5b34159bd8270bfb8b235b0b  .codex-plugin/plugin.json
 a7bebae9fb01c838d6c75fc784129e28be571233fa66ff5ee8039b574f35ccf7  assets/icon.png
 fc38b64e4df1e0b72c35764bef6c4c05430d97c9009ad0ecc8a9e75b4deab232  configure-local.mjs
 73dc6028b3b070257c7c31f252d11e55a9e096f4aed0f187f10cb21716e1e6d7  dist/client.js