@inerrata-corporation/errata 2.0.22-dev.4676 → 2.0.23-dev.4682

package/consolidate-worker.mjs

@@ -17935,7 +17935,12 @@ CREATE UNIQUE INDEX IF NOT EXISTS edges_triple ON edges(from_id, type, to_id);
 var TEMPORAL_INDEX_SQL = `
 CREATE INDEX IF NOT EXISTS nodes_live ON nodes(label, valid_to);
 CREATE INDEX IF NOT EXISTS nodes_live_count ON nodes(valid_to);
-CREATE INDEX IF NOT EXISTS nodes_live_recent ON nodes(label, last_updated_at DESC) WHERE valid_to IS NULL;
+-- Problems by recency (the only label read newest-first). Over every live row,
+-- each write that stamps last_updated_at moved a code symbol's entry from a
+-- scattered leaf: ~19 KB per position-only symbol rewrite on a 1.1 GB store.
+-- label stays the leading column so label = 'Problem' plans without a sort.
+DROP INDEX IF EXISTS nodes_live_recent;
+CREATE INDEX IF NOT EXISTS nodes_live_problem_recent ON nodes(label, last_updated_at DESC) WHERE valid_to IS NULL AND label = 'Problem';
 -- "Anything created since the watermark?" guards (the fold, regression and
 -- canonical-bind sweeps run one per session boundary). Without it the planner
 -- walks nodes_live and reads every live row of the label to test created_at:
@@ -18009,24 +18014,34 @@ CREATE INDEX IF NOT EXISTS nodes_closed_relpath ON nodes(json_extract(attrs_json
 -- Live rows by name, for looking up the few symbols a statement mentions
 -- instead of hydrating every code symbol per minted problem.
 CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) WHERE valid_to IS NULL;
+-- The six single-attr lookups below are partial on the attr being present: each
+-- is read only by equality (or IN), which implies it. Keyed on NULL for the ~95%
+-- of rows that lack the attr, every write to such a row's attrs rewrote its NULL
+-- entry: ~25 KB per position-only symbol rewrite on a 1.1 GB store (2026-10-21).
+DROP INDEX IF EXISTS nodes_anchor_hint_path;
+DROP INDEX IF EXISTS nodes_command_signature;
+DROP INDEX IF EXISTS nodes_diag_command;
+DROP INDEX IF EXISTS nodes_lsp_rel_path;
+DROP INDEX IF EXISTS nodes_cloud_node_id;
+DROP INDEX IF EXISTS nodes_enrichment_pending;
 -- Problems by the file their anchor hint names: the harvest upgrades hints for
 -- every edited file of every turn, and a scan parses every Problem's attrs.
-CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path ON nodes(json_extract(attrs_json, '$.anchorHint.path')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path_v2 ON nodes(json_extract(attrs_json, '$.anchorHint.path')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.anchorHint.path') IS NOT NULL;
 -- Problems by the command / checker / file that opened them. The generalizer
 -- looked these up per shell or tool EVENT by hydrating every Problem: ~12s of
 -- every minute of daemon main-thread time on a 3.4k-Problem store (2026-10-05).
-CREATE INDEX IF NOT EXISTS nodes_command_signature ON nodes(json_extract(attrs_json, '$.commandSignature')) WHERE valid_to IS NULL;
-CREATE INDEX IF NOT EXISTS nodes_diag_command ON nodes(json_extract(attrs_json, '$.diagCommand')) WHERE valid_to IS NULL;
-CREATE INDEX IF NOT EXISTS nodes_lsp_rel_path ON nodes(json_extract(attrs_json, '$.lspRelPath')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_command_signature_v2 ON nodes(json_extract(attrs_json, '$.commandSignature')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.commandSignature') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_diag_command_v2 ON nodes(json_extract(attrs_json, '$.diagCommand')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.diagCommand') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_lsp_rel_path_v2 ON nodes(json_extract(attrs_json, '$.lspRelPath')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.lspRelPath') IS NOT NULL;
 -- Local nodes by the cloud twin their upload receipt recorded. Every burst /
 -- search fusion folds the Network copy of the caller's own knowledge back onto
 -- the local node; unindexed, the reverse lookup was a ~300ms attrs scan per call.
-CREATE INDEX IF NOT EXISTS nodes_cloud_node_id ON nodes(json_extract(attrs_json, '$.cloudNodeId')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_cloud_node_id_v2 ON nodes(json_extract(attrs_json, '$.cloudNodeId')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.cloudNodeId') IS NOT NULL;
 -- Nodes still waiting on a root-cause ask. The MCP server checks this on EVERY
 -- tool response (the enrichment piggyback), so it must not parse every
--- Solution's and Problem's attrs per call. Not partial: the Problem pull reads
+-- Solution's and Problem's attrs per call. Any version: the Problem pull reads
 -- closed versions too.
-CREATE INDEX IF NOT EXISTS nodes_enrichment_pending ON nodes(json_extract(attrs_json, '$.enrichmentPending'));
+CREATE INDEX IF NOT EXISTS nodes_enrichment_pending_v2 ON nodes(json_extract(attrs_json, '$.enrichmentPending')) WHERE json_extract(attrs_json, '$.enrichmentPending') IS NOT NULL;
 -- Revisit flags, any label, any version: listNeedsRevisit's as-of read runs on
 -- every context render and otherwise json-checks every row (10.3 s on a 324k-row
 -- store, to return zero flags). The predicate must stay textually identical to
@@ -18092,6 +18107,30 @@ function rowToEdge(r) {
 }
 var FINGERPRINT_INDEXED_LABELS = ["Problem", "Vulnerability", "Solution", "RootCause"];
 var NODE_LABELS_CHUNK = 256;
+var NODE_UPSERT_COLUMNS = [
+  "label",
+  "description",
+  "extraction_confidence",
+  "embedding_json",
+  "embedding_blob",
+  "cumulative_surprise",
+  "peak_surprise",
+  "cumulative_hits",
+  "last_updated_at",
+  "memory_tier",
+  "page_rank",
+  "is_landmark",
+  "community",
+  "stability",
+  "last_reinforced_at_seq",
+  "attrs_json"
+];
+var EDGE_UPSERT_COLUMNS = ["confidence", "last_seen_at", "nav_successes", "nav_failures", "valid_to", "attrs_json"];
+function sameSqlValue(a, b) {
+  if (a === b || a == null && b == null) return true;
+  if (a instanceof Uint8Array && b instanceof Uint8Array) return Buffer.compare(a, b) === 0;
+  return false;
+}
 var PRIOR_TAG_MARKER = '"priorTag":true';
 var SqliteGraphStore = class {
   db;
@@ -18099,6 +18138,8 @@ var SqliteGraphStore = class {
   // used to prepare it on every call: ~600ms of a 2.5s drain build on a live
   // 225k-node store was statement compilation alone. Keyed by the SQL text.
   typedEdgeStmts = /* @__PURE__ */ new Map();
+  /** Narrow merge updates, keyed by table and the columns they set. */
+  changedColumnStmts = /* @__PURE__ */ new Map();
   stmts;
   /** Unified graph-mutation counter (see GraphStore.mutationCount). Bumped on
    *  every node/edge upsert — code-index and capture alike — so the consolidation
@@ -18182,6 +18223,8 @@ var SqliteGraphStore = class {
           last_reinforced_at_seq = excluded.last_reinforced_at_seq,
           attrs_json = excluded.attrs_json
       `),
+      nodeUpsertTarget: this.db.prepare(`SELECT rowid AS rid, ${NODE_UPSERT_COLUMNS.join(", ")} FROM nodes WHERE id = ?`),
+      edgeUpsertTarget: this.db.prepare(`SELECT rowid AS rid, ${EDGE_UPSERT_COLUMNS.join(", ")} FROM edges WHERE from_id = ? AND type = ? AND to_id = ?`),
       getNode: this.db.prepare("SELECT nodes.*, (SELECT x.attrs_json FROM node_exposure x WHERE x.id = nodes.id) AS exposure_json FROM nodes WHERE id = ?"),
       exposureOf: this.db.prepare("SELECT attrs_json FROM node_exposure WHERE id = ?"),
       writeExposure: this.db.prepare("INSERT INTO node_exposure(id, attrs_json) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET attrs_json = excluded.attrs_json"),
@@ -18550,7 +18593,7 @@ var SqliteGraphStore = class {
   }
   mergeNode(node) {
     this.mutations++;
-    this.stmts.insertNode.run({
+    const values = {
       id: node.id,
       label: node.label,
       description: node.description,
@@ -18577,7 +18620,23 @@ var SqliteGraphStore = class {
       created_at_seq: node.createdAtSeq ?? null,
       last_reinforced_at_seq: node.lastReinforcedAtSeq ?? null,
       attrs_json: this.nodeAttrsJson(node.id, node.attrs ?? {})
-    });
+    };
+    const current = this.stmts.nodeUpsertTarget.get(node.id);
+    if (current) this.writeChangedColumns("nodes", NODE_UPSERT_COLUMNS, current, values);
+    else this.stmts.insertNode.run(values);
+  }
+  /** What the upsert's ON CONFLICT would write over `current`, setting only the
+   *  columns whose value moves (NODE_UPSERT_COLUMNS says why). */
+  writeChangedColumns(table, columns2, current, next) {
+    const changed = columns2.filter((c) => !sameSqlValue(current[c], next[c]));
+    if (changed.length === 0) return;
+    const key = `${table}:${changed.join(",")}`;
+    let stmt2 = this.changedColumnStmts.get(key);
+    if (!stmt2) {
+      stmt2 = this.db.prepare(`UPDATE ${table} SET ${changed.map((c) => `${c} = :${c}`).join(", ")} WHERE rowid = :rid`);
+      this.changedColumnStmts.set(key, stmt2);
+    }
+    stmt2.run({ rid: current["rid"], ...Object.fromEntries(changed.map((c) => [c, next[c]])) });
   }
   /** mergeNode, unless the live row already holds this content. Content is what
    *  the columns a merge rewrites from the producer (label, description, attrs,
@@ -18711,7 +18770,7 @@ var SqliteGraphStore = class {
       return;
     }
     this.mutations++;
-    this.stmts.insertEdge.run({
+    const values = {
       id: edge.id,
       from_id: edge.from,
       to_id: edge.to,
@@ -18725,6 +18784,16 @@ var SqliteGraphStore = class {
       valid_from: edge.validFrom ?? edge.createdAt,
       valid_to: edge.validTo ?? null,
       attrs_json: JSON.stringify(edge.attrs ?? {})
+    };
+    const current = this.stmts.edgeUpsertTarget.get(edge.from, edge.type, edge.to);
+    if (!current) {
+      this.stmts.insertEdge.run(values);
+      return;
+    }
+    this.writeChangedColumns("edges", EDGE_UPSERT_COLUMNS, current, {
+      ...values,
+      confidence: Math.max(current["confidence"], edge.confidence),
+      valid_to: null
     });
   }
   /** mergeEdge, unless the live edge already holds this content: same attrs, and
@@ -18939,8 +19008,8 @@ var SqliteGraphStore = class {
       after = rows[rows.length - 1].rid;
     }
   }
-  recentNodeIds(label, limit) {
-    const rows = this.db.prepare("SELECT id FROM nodes WHERE label = ? AND valid_to IS NULL ORDER BY last_updated_at DESC LIMIT ?").all(label, Math.max(0, limit));
+  recentProblemIds(limit) {
+    const rows = this.db.prepare("SELECT id FROM nodes WHERE label = 'Problem' AND valid_to IS NULL ORDER BY last_updated_at DESC LIMIT ?").all(Math.max(0, limit));
     return rows.map((r) => r.id);
   }
   recentOpenProblemCandidates(opts) {
@@ -19381,7 +19450,7 @@ var SqliteGraphStore = class {
       const slice = cloudIds.slice(i, i + CHUNK);
       if (slice.length === 0) continue;
       const rows = this.db.prepare(
-        `SELECT id, json_extract(attrs_json, '$.cloudNodeId') AS cloud FROM nodes INDEXED BY nodes_cloud_node_id WHERE json_extract(attrs_json, '$.cloudNodeId') IN (${slice.map(() => "?").join(",")}) AND valid_to IS NULL ORDER BY id`
+        `SELECT id, json_extract(attrs_json, '$.cloudNodeId') AS cloud FROM nodes INDEXED BY nodes_cloud_node_id_v2 WHERE json_extract(attrs_json, '$.cloudNodeId') IN (${slice.map(() => "?").join(",")}) AND valid_to IS NULL ORDER BY id`
       ).all(...slice);
       for (const r of rows) out.set(r.cloud, [...out.get(r.cloud) ?? [], r.id]);
     }

package/errata.mjs

@@ -20756,10 +20756,15 @@ function rowToEdge(r) {
     attrs: JSON.parse(r.attrs_json)
   };
 }
+function sameSqlValue(a, b) {
+  if (a === b || a == null && b == null) return true;
+  if (a instanceof Uint8Array && b instanceof Uint8Array) return Buffer.compare(a, b) === 0;
+  return false;
+}
 function openGraphStore(opts) {
   return new SqliteGraphStore(opts);
 }
-var PAGE_RANK_SCALE_KEY, TEXT_SEARCH_COLUMNS, LOCAL_RULE_OVERRIDES, SCHEMA_VERSION, SESSION_REPAIR_KEY, EXPOSURE_SIDE_KEY, SESSION_EVIDENCE_PREDICATE, SCHEMA_SQL, TEMPORAL_INDEX_SQL, FINGERPRINT_INDEXED_LABELS, NODE_LABELS_CHUNK, PRIOR_TAG_MARKER, SqliteGraphStore;
+var PAGE_RANK_SCALE_KEY, TEXT_SEARCH_COLUMNS, LOCAL_RULE_OVERRIDES, SCHEMA_VERSION, SESSION_REPAIR_KEY, EXPOSURE_SIDE_KEY, SESSION_EVIDENCE_PREDICATE, SCHEMA_SQL, TEMPORAL_INDEX_SQL, FINGERPRINT_INDEXED_LABELS, NODE_LABELS_CHUNK, NODE_UPSERT_COLUMNS, EDGE_UPSERT_COLUMNS, PRIOR_TAG_MARKER, SqliteGraphStore;
 var init_store = __esm({
   "../../packages/local-graph/src/store.ts"() {
     "use strict";
@@ -20914,7 +20919,12 @@ CREATE UNIQUE INDEX IF NOT EXISTS edges_triple ON edges(from_id, type, to_id);
     TEMPORAL_INDEX_SQL = `
 CREATE INDEX IF NOT EXISTS nodes_live ON nodes(label, valid_to);
 CREATE INDEX IF NOT EXISTS nodes_live_count ON nodes(valid_to);
-CREATE INDEX IF NOT EXISTS nodes_live_recent ON nodes(label, last_updated_at DESC) WHERE valid_to IS NULL;
+-- Problems by recency (the only label read newest-first). Over every live row,
+-- each write that stamps last_updated_at moved a code symbol's entry from a
+-- scattered leaf: ~19 KB per position-only symbol rewrite on a 1.1 GB store.
+-- label stays the leading column so label = 'Problem' plans without a sort.
+DROP INDEX IF EXISTS nodes_live_recent;
+CREATE INDEX IF NOT EXISTS nodes_live_problem_recent ON nodes(label, last_updated_at DESC) WHERE valid_to IS NULL AND label = 'Problem';
 -- "Anything created since the watermark?" guards (the fold, regression and
 -- canonical-bind sweeps run one per session boundary). Without it the planner
 -- walks nodes_live and reads every live row of the label to test created_at:
@@ -20988,24 +20998,34 @@ CREATE INDEX IF NOT EXISTS nodes_closed_relpath ON nodes(json_extract(attrs_json
 -- Live rows by name, for looking up the few symbols a statement mentions
 -- instead of hydrating every code symbol per minted problem.
 CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) WHERE valid_to IS NULL;
+-- The six single-attr lookups below are partial on the attr being present: each
+-- is read only by equality (or IN), which implies it. Keyed on NULL for the ~95%
+-- of rows that lack the attr, every write to such a row's attrs rewrote its NULL
+-- entry: ~25 KB per position-only symbol rewrite on a 1.1 GB store (2026-10-21).
+DROP INDEX IF EXISTS nodes_anchor_hint_path;
+DROP INDEX IF EXISTS nodes_command_signature;
+DROP INDEX IF EXISTS nodes_diag_command;
+DROP INDEX IF EXISTS nodes_lsp_rel_path;
+DROP INDEX IF EXISTS nodes_cloud_node_id;
+DROP INDEX IF EXISTS nodes_enrichment_pending;
 -- Problems by the file their anchor hint names: the harvest upgrades hints for
 -- every edited file of every turn, and a scan parses every Problem's attrs.
-CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path ON nodes(json_extract(attrs_json, '$.anchorHint.path')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path_v2 ON nodes(json_extract(attrs_json, '$.anchorHint.path')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.anchorHint.path') IS NOT NULL;
 -- Problems by the command / checker / file that opened them. The generalizer
 -- looked these up per shell or tool EVENT by hydrating every Problem: ~12s of
 -- every minute of daemon main-thread time on a 3.4k-Problem store (2026-10-05).
-CREATE INDEX IF NOT EXISTS nodes_command_signature ON nodes(json_extract(attrs_json, '$.commandSignature')) WHERE valid_to IS NULL;
-CREATE INDEX IF NOT EXISTS nodes_diag_command ON nodes(json_extract(attrs_json, '$.diagCommand')) WHERE valid_to IS NULL;
-CREATE INDEX IF NOT EXISTS nodes_lsp_rel_path ON nodes(json_extract(attrs_json, '$.lspRelPath')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_command_signature_v2 ON nodes(json_extract(attrs_json, '$.commandSignature')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.commandSignature') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_diag_command_v2 ON nodes(json_extract(attrs_json, '$.diagCommand')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.diagCommand') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_lsp_rel_path_v2 ON nodes(json_extract(attrs_json, '$.lspRelPath')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.lspRelPath') IS NOT NULL;
 -- Local nodes by the cloud twin their upload receipt recorded. Every burst /
 -- search fusion folds the Network copy of the caller's own knowledge back onto
 -- the local node; unindexed, the reverse lookup was a ~300ms attrs scan per call.
-CREATE INDEX IF NOT EXISTS nodes_cloud_node_id ON nodes(json_extract(attrs_json, '$.cloudNodeId')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_cloud_node_id_v2 ON nodes(json_extract(attrs_json, '$.cloudNodeId')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.cloudNodeId') IS NOT NULL;
 -- Nodes still waiting on a root-cause ask. The MCP server checks this on EVERY
 -- tool response (the enrichment piggyback), so it must not parse every
--- Solution's and Problem's attrs per call. Not partial: the Problem pull reads
+-- Solution's and Problem's attrs per call. Any version: the Problem pull reads
 -- closed versions too.
-CREATE INDEX IF NOT EXISTS nodes_enrichment_pending ON nodes(json_extract(attrs_json, '$.enrichmentPending'));
+CREATE INDEX IF NOT EXISTS nodes_enrichment_pending_v2 ON nodes(json_extract(attrs_json, '$.enrichmentPending')) WHERE json_extract(attrs_json, '$.enrichmentPending') IS NOT NULL;
 -- Revisit flags, any label, any version: listNeedsRevisit's as-of read runs on
 -- every context render and otherwise json-checks every row (10.3 s on a 324k-row
 -- store, to return zero flags). The predicate must stay textually identical to
@@ -21014,6 +21034,25 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
 `;
     FINGERPRINT_INDEXED_LABELS = ["Problem", "Vulnerability", "Solution", "RootCause"];
     NODE_LABELS_CHUNK = 256;
+    NODE_UPSERT_COLUMNS = [
+      "label",
+      "description",
+      "extraction_confidence",
+      "embedding_json",
+      "embedding_blob",
+      "cumulative_surprise",
+      "peak_surprise",
+      "cumulative_hits",
+      "last_updated_at",
+      "memory_tier",
+      "page_rank",
+      "is_landmark",
+      "community",
+      "stability",
+      "last_reinforced_at_seq",
+      "attrs_json"
+    ];
+    EDGE_UPSERT_COLUMNS = ["confidence", "last_seen_at", "nav_successes", "nav_failures", "valid_to", "attrs_json"];
     PRIOR_TAG_MARKER = '"priorTag":true';
     SqliteGraphStore = class {
       db;
@@ -21021,6 +21060,8 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
       // used to prepare it on every call: ~600ms of a 2.5s drain build on a live
       // 225k-node store was statement compilation alone. Keyed by the SQL text.
       typedEdgeStmts = /* @__PURE__ */ new Map();
+      /** Narrow merge updates, keyed by table and the columns they set. */
+      changedColumnStmts = /* @__PURE__ */ new Map();
       stmts;
       /** Unified graph-mutation counter (see GraphStore.mutationCount). Bumped on
        *  every node/edge upsert — code-index and capture alike — so the consolidation
@@ -21104,6 +21145,8 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
           last_reinforced_at_seq = excluded.last_reinforced_at_seq,
           attrs_json = excluded.attrs_json
       `),
+          nodeUpsertTarget: this.db.prepare(`SELECT rowid AS rid, ${NODE_UPSERT_COLUMNS.join(", ")} FROM nodes WHERE id = ?`),
+          edgeUpsertTarget: this.db.prepare(`SELECT rowid AS rid, ${EDGE_UPSERT_COLUMNS.join(", ")} FROM edges WHERE from_id = ? AND type = ? AND to_id = ?`),
           getNode: this.db.prepare("SELECT nodes.*, (SELECT x.attrs_json FROM node_exposure x WHERE x.id = nodes.id) AS exposure_json FROM nodes WHERE id = ?"),
           exposureOf: this.db.prepare("SELECT attrs_json FROM node_exposure WHERE id = ?"),
           writeExposure: this.db.prepare("INSERT INTO node_exposure(id, attrs_json) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET attrs_json = excluded.attrs_json"),
@@ -21472,7 +21515,7 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
       }
       mergeNode(node2) {
         this.mutations++;
-        this.stmts.insertNode.run({
+        const values = {
           id: node2.id,
           label: node2.label,
           description: node2.description,
@@ -21499,7 +21542,23 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
           created_at_seq: node2.createdAtSeq ?? null,
           last_reinforced_at_seq: node2.lastReinforcedAtSeq ?? null,
           attrs_json: this.nodeAttrsJson(node2.id, node2.attrs ?? {})
-        });
+        };
+        const current = this.stmts.nodeUpsertTarget.get(node2.id);
+        if (current) this.writeChangedColumns("nodes", NODE_UPSERT_COLUMNS, current, values);
+        else this.stmts.insertNode.run(values);
+      }
+      /** What the upsert's ON CONFLICT would write over `current`, setting only the
+       *  columns whose value moves (NODE_UPSERT_COLUMNS says why). */
+      writeChangedColumns(table, columns2, current, next) {
+        const changed = columns2.filter((c) => !sameSqlValue(current[c], next[c]));
+        if (changed.length === 0) return;
+        const key = `${table}:${changed.join(",")}`;
+        let stmt2 = this.changedColumnStmts.get(key);
+        if (!stmt2) {
+          stmt2 = this.db.prepare(`UPDATE ${table} SET ${changed.map((c) => `${c} = :${c}`).join(", ")} WHERE rowid = :rid`);
+          this.changedColumnStmts.set(key, stmt2);
+        }
+        stmt2.run({ rid: current["rid"], ...Object.fromEntries(changed.map((c) => [c, next[c]])) });
       }
       /** mergeNode, unless the live row already holds this content. Content is what
        *  the columns a merge rewrites from the producer (label, description, attrs,
@@ -21633,7 +21692,7 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
           return;
         }
         this.mutations++;
-        this.stmts.insertEdge.run({
+        const values = {
           id: edge2.id,
           from_id: edge2.from,
           to_id: edge2.to,
@@ -21647,6 +21706,16 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
           valid_from: edge2.validFrom ?? edge2.createdAt,
           valid_to: edge2.validTo ?? null,
           attrs_json: JSON.stringify(edge2.attrs ?? {})
+        };
+        const current = this.stmts.edgeUpsertTarget.get(edge2.from, edge2.type, edge2.to);
+        if (!current) {
+          this.stmts.insertEdge.run(values);
+          return;
+        }
+        this.writeChangedColumns("edges", EDGE_UPSERT_COLUMNS, current, {
+          ...values,
+          confidence: Math.max(current["confidence"], edge2.confidence),
+          valid_to: null
         });
       }
       /** mergeEdge, unless the live edge already holds this content: same attrs, and
@@ -21861,8 +21930,8 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
           after = rows[rows.length - 1].rid;
         }
       }
-      recentNodeIds(label, limit) {
-        const rows = this.db.prepare("SELECT id FROM nodes WHERE label = ? AND valid_to IS NULL ORDER BY last_updated_at DESC LIMIT ?").all(label, Math.max(0, limit));
+      recentProblemIds(limit) {
+        const rows = this.db.prepare("SELECT id FROM nodes WHERE label = 'Problem' AND valid_to IS NULL ORDER BY last_updated_at DESC LIMIT ?").all(Math.max(0, limit));
         return rows.map((r) => r.id);
       }
       recentOpenProblemCandidates(opts) {
@@ -22303,7 +22372,7 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
           const slice = cloudIds.slice(i2, i2 + CHUNK2);
           if (slice.length === 0) continue;
           const rows = this.db.prepare(
-            `SELECT id, json_extract(attrs_json, '$.cloudNodeId') AS cloud FROM nodes INDEXED BY nodes_cloud_node_id WHERE json_extract(attrs_json, '$.cloudNodeId') IN (${slice.map(() => "?").join(",")}) AND valid_to IS NULL ORDER BY id`
+            `SELECT id, json_extract(attrs_json, '$.cloudNodeId') AS cloud FROM nodes INDEXED BY nodes_cloud_node_id_v2 WHERE json_extract(attrs_json, '$.cloudNodeId') IN (${slice.map(() => "?").join(",")}) AND valid_to IS NULL ORDER BY id`
           ).all(...slice);
           for (const r of rows) out2.set(r.cloud, [...out2.get(r.cloud) ?? [], r.id]);
         }
@@ -87394,7 +87463,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.22-dev.4676" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.23-dev.4682" : "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;
@@ -88036,7 +88105,7 @@ function createWorkspaceEngine(opts) {
     void outboundStack().then((stack) => {
       if (!(opts.syncConsent ?? consentNow().sync)) return;
       const norm = normStackTokens;
-      const seed = store.recentNodeIds("Problem", 6);
+      const seed = store.recentProblemIds(6);
       const q = {
         stack,
         domains: norm(profile.domains),

package/generalize-worker.mjs

@@ -16332,7 +16332,12 @@ CREATE UNIQUE INDEX IF NOT EXISTS edges_triple ON edges(from_id, type, to_id);
 var TEMPORAL_INDEX_SQL = `
 CREATE INDEX IF NOT EXISTS nodes_live ON nodes(label, valid_to);
 CREATE INDEX IF NOT EXISTS nodes_live_count ON nodes(valid_to);
-CREATE INDEX IF NOT EXISTS nodes_live_recent ON nodes(label, last_updated_at DESC) WHERE valid_to IS NULL;
+-- Problems by recency (the only label read newest-first). Over every live row,
+-- each write that stamps last_updated_at moved a code symbol's entry from a
+-- scattered leaf: ~19 KB per position-only symbol rewrite on a 1.1 GB store.
+-- label stays the leading column so label = 'Problem' plans without a sort.
+DROP INDEX IF EXISTS nodes_live_recent;
+CREATE INDEX IF NOT EXISTS nodes_live_problem_recent ON nodes(label, last_updated_at DESC) WHERE valid_to IS NULL AND label = 'Problem';
 -- "Anything created since the watermark?" guards (the fold, regression and
 -- canonical-bind sweeps run one per session boundary). Without it the planner
 -- walks nodes_live and reads every live row of the label to test created_at:
@@ -16406,24 +16411,34 @@ CREATE INDEX IF NOT EXISTS nodes_closed_relpath ON nodes(json_extract(attrs_json
 -- Live rows by name, for looking up the few symbols a statement mentions
 -- instead of hydrating every code symbol per minted problem.
 CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) WHERE valid_to IS NULL;
+-- The six single-attr lookups below are partial on the attr being present: each
+-- is read only by equality (or IN), which implies it. Keyed on NULL for the ~95%
+-- of rows that lack the attr, every write to such a row's attrs rewrote its NULL
+-- entry: ~25 KB per position-only symbol rewrite on a 1.1 GB store (2026-10-21).
+DROP INDEX IF EXISTS nodes_anchor_hint_path;
+DROP INDEX IF EXISTS nodes_command_signature;
+DROP INDEX IF EXISTS nodes_diag_command;
+DROP INDEX IF EXISTS nodes_lsp_rel_path;
+DROP INDEX IF EXISTS nodes_cloud_node_id;
+DROP INDEX IF EXISTS nodes_enrichment_pending;
 -- Problems by the file their anchor hint names: the harvest upgrades hints for
 -- every edited file of every turn, and a scan parses every Problem's attrs.
-CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path ON nodes(json_extract(attrs_json, '$.anchorHint.path')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path_v2 ON nodes(json_extract(attrs_json, '$.anchorHint.path')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.anchorHint.path') IS NOT NULL;
 -- Problems by the command / checker / file that opened them. The generalizer
 -- looked these up per shell or tool EVENT by hydrating every Problem: ~12s of
 -- every minute of daemon main-thread time on a 3.4k-Problem store (2026-10-05).
-CREATE INDEX IF NOT EXISTS nodes_command_signature ON nodes(json_extract(attrs_json, '$.commandSignature')) WHERE valid_to IS NULL;
-CREATE INDEX IF NOT EXISTS nodes_diag_command ON nodes(json_extract(attrs_json, '$.diagCommand')) WHERE valid_to IS NULL;
-CREATE INDEX IF NOT EXISTS nodes_lsp_rel_path ON nodes(json_extract(attrs_json, '$.lspRelPath')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_command_signature_v2 ON nodes(json_extract(attrs_json, '$.commandSignature')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.commandSignature') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_diag_command_v2 ON nodes(json_extract(attrs_json, '$.diagCommand')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.diagCommand') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_lsp_rel_path_v2 ON nodes(json_extract(attrs_json, '$.lspRelPath')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.lspRelPath') IS NOT NULL;
 -- Local nodes by the cloud twin their upload receipt recorded. Every burst /
 -- search fusion folds the Network copy of the caller's own knowledge back onto
 -- the local node; unindexed, the reverse lookup was a ~300ms attrs scan per call.
-CREATE INDEX IF NOT EXISTS nodes_cloud_node_id ON nodes(json_extract(attrs_json, '$.cloudNodeId')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_cloud_node_id_v2 ON nodes(json_extract(attrs_json, '$.cloudNodeId')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.cloudNodeId') IS NOT NULL;
 -- Nodes still waiting on a root-cause ask. The MCP server checks this on EVERY
 -- tool response (the enrichment piggyback), so it must not parse every
--- Solution's and Problem's attrs per call. Not partial: the Problem pull reads
+-- Solution's and Problem's attrs per call. Any version: the Problem pull reads
 -- closed versions too.
-CREATE INDEX IF NOT EXISTS nodes_enrichment_pending ON nodes(json_extract(attrs_json, '$.enrichmentPending'));
+CREATE INDEX IF NOT EXISTS nodes_enrichment_pending_v2 ON nodes(json_extract(attrs_json, '$.enrichmentPending')) WHERE json_extract(attrs_json, '$.enrichmentPending') IS NOT NULL;
 -- Revisit flags, any label, any version: listNeedsRevisit's as-of read runs on
 -- every context render and otherwise json-checks every row (10.3 s on a 324k-row
 -- store, to return zero flags). The predicate must stay textually identical to
@@ -16489,6 +16504,30 @@ function rowToEdge(r) {
 }
 var FINGERPRINT_INDEXED_LABELS = ["Problem", "Vulnerability", "Solution", "RootCause"];
 var NODE_LABELS_CHUNK = 256;
+var NODE_UPSERT_COLUMNS = [
+  "label",
+  "description",
+  "extraction_confidence",
+  "embedding_json",
+  "embedding_blob",
+  "cumulative_surprise",
+  "peak_surprise",
+  "cumulative_hits",
+  "last_updated_at",
+  "memory_tier",
+  "page_rank",
+  "is_landmark",
+  "community",
+  "stability",
+  "last_reinforced_at_seq",
+  "attrs_json"
+];
+var EDGE_UPSERT_COLUMNS = ["confidence", "last_seen_at", "nav_successes", "nav_failures", "valid_to", "attrs_json"];
+function sameSqlValue(a, b) {
+  if (a === b || a == null && b == null) return true;
+  if (a instanceof Uint8Array && b instanceof Uint8Array) return Buffer.compare(a, b) === 0;
+  return false;
+}
 var PRIOR_TAG_MARKER = '"priorTag":true';
 var SqliteGraphStore = class {
   db;
@@ -16496,6 +16535,8 @@ var SqliteGraphStore = class {
   // used to prepare it on every call: ~600ms of a 2.5s drain build on a live
   // 225k-node store was statement compilation alone. Keyed by the SQL text.
   typedEdgeStmts = /* @__PURE__ */ new Map();
+  /** Narrow merge updates, keyed by table and the columns they set. */
+  changedColumnStmts = /* @__PURE__ */ new Map();
   stmts;
   /** Unified graph-mutation counter (see GraphStore.mutationCount). Bumped on
    *  every node/edge upsert — code-index and capture alike — so the consolidation
@@ -16579,6 +16620,8 @@ var SqliteGraphStore = class {
           last_reinforced_at_seq = excluded.last_reinforced_at_seq,
           attrs_json = excluded.attrs_json
       `),
+      nodeUpsertTarget: this.db.prepare(`SELECT rowid AS rid, ${NODE_UPSERT_COLUMNS.join(", ")} FROM nodes WHERE id = ?`),
+      edgeUpsertTarget: this.db.prepare(`SELECT rowid AS rid, ${EDGE_UPSERT_COLUMNS.join(", ")} FROM edges WHERE from_id = ? AND type = ? AND to_id = ?`),
       getNode: this.db.prepare("SELECT nodes.*, (SELECT x.attrs_json FROM node_exposure x WHERE x.id = nodes.id) AS exposure_json FROM nodes WHERE id = ?"),
       exposureOf: this.db.prepare("SELECT attrs_json FROM node_exposure WHERE id = ?"),
       writeExposure: this.db.prepare("INSERT INTO node_exposure(id, attrs_json) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET attrs_json = excluded.attrs_json"),
@@ -16947,7 +16990,7 @@ var SqliteGraphStore = class {
   }
   mergeNode(node) {
     this.mutations++;
-    this.stmts.insertNode.run({
+    const values = {
       id: node.id,
       label: node.label,
       description: node.description,
@@ -16974,7 +17017,23 @@ var SqliteGraphStore = class {
       created_at_seq: node.createdAtSeq ?? null,
       last_reinforced_at_seq: node.lastReinforcedAtSeq ?? null,
       attrs_json: this.nodeAttrsJson(node.id, node.attrs ?? {})
-    });
+    };
+    const current = this.stmts.nodeUpsertTarget.get(node.id);
+    if (current) this.writeChangedColumns("nodes", NODE_UPSERT_COLUMNS, current, values);
+    else this.stmts.insertNode.run(values);
+  }
+  /** What the upsert's ON CONFLICT would write over `current`, setting only the
+   *  columns whose value moves (NODE_UPSERT_COLUMNS says why). */
+  writeChangedColumns(table, columns2, current, next) {
+    const changed = columns2.filter((c) => !sameSqlValue(current[c], next[c]));
+    if (changed.length === 0) return;
+    const key = `${table}:${changed.join(",")}`;
+    let stmt2 = this.changedColumnStmts.get(key);
+    if (!stmt2) {
+      stmt2 = this.db.prepare(`UPDATE ${table} SET ${changed.map((c) => `${c} = :${c}`).join(", ")} WHERE rowid = :rid`);
+      this.changedColumnStmts.set(key, stmt2);
+    }
+    stmt2.run({ rid: current["rid"], ...Object.fromEntries(changed.map((c) => [c, next[c]])) });
   }
   /** mergeNode, unless the live row already holds this content. Content is what
    *  the columns a merge rewrites from the producer (label, description, attrs,
@@ -17108,7 +17167,7 @@ var SqliteGraphStore = class {
       return;
     }
     this.mutations++;
-    this.stmts.insertEdge.run({
+    const values = {
       id: edge.id,
       from_id: edge.from,
       to_id: edge.to,
@@ -17122,6 +17181,16 @@ var SqliteGraphStore = class {
       valid_from: edge.validFrom ?? edge.createdAt,
       valid_to: edge.validTo ?? null,
       attrs_json: JSON.stringify(edge.attrs ?? {})
+    };
+    const current = this.stmts.edgeUpsertTarget.get(edge.from, edge.type, edge.to);
+    if (!current) {
+      this.stmts.insertEdge.run(values);
+      return;
+    }
+    this.writeChangedColumns("edges", EDGE_UPSERT_COLUMNS, current, {
+      ...values,
+      confidence: Math.max(current["confidence"], edge.confidence),
+      valid_to: null
     });
   }
   /** mergeEdge, unless the live edge already holds this content: same attrs, and
@@ -17336,8 +17405,8 @@ var SqliteGraphStore = class {
       after = rows[rows.length - 1].rid;
     }
   }
-  recentNodeIds(label, limit) {
-    const rows = this.db.prepare("SELECT id FROM nodes WHERE label = ? AND valid_to IS NULL ORDER BY last_updated_at DESC LIMIT ?").all(label, Math.max(0, limit));
+  recentProblemIds(limit) {
+    const rows = this.db.prepare("SELECT id FROM nodes WHERE label = 'Problem' AND valid_to IS NULL ORDER BY last_updated_at DESC LIMIT ?").all(Math.max(0, limit));
     return rows.map((r) => r.id);
   }
   recentOpenProblemCandidates(opts) {
@@ -17778,7 +17847,7 @@ var SqliteGraphStore = class {
       const slice = cloudIds.slice(i, i + CHUNK);
       if (slice.length === 0) continue;
       const rows = this.db.prepare(
-        `SELECT id, json_extract(attrs_json, '$.cloudNodeId') AS cloud FROM nodes INDEXED BY nodes_cloud_node_id WHERE json_extract(attrs_json, '$.cloudNodeId') IN (${slice.map(() => "?").join(",")}) AND valid_to IS NULL ORDER BY id`
+        `SELECT id, json_extract(attrs_json, '$.cloudNodeId') AS cloud FROM nodes INDEXED BY nodes_cloud_node_id_v2 WHERE json_extract(attrs_json, '$.cloudNodeId') IN (${slice.map(() => "?").join(",")}) AND valid_to IS NULL ORDER BY id`
       ).all(...slice);
       for (const r of rows) out.set(r.cloud, [...out.get(r.cloud) ?? [], r.id]);
     }

package/package.json

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

package/pass-worker.mjs

@@ -27304,7 +27304,12 @@ CREATE UNIQUE INDEX IF NOT EXISTS edges_triple ON edges(from_id, type, to_id);
 var TEMPORAL_INDEX_SQL = `
 CREATE INDEX IF NOT EXISTS nodes_live ON nodes(label, valid_to);
 CREATE INDEX IF NOT EXISTS nodes_live_count ON nodes(valid_to);
-CREATE INDEX IF NOT EXISTS nodes_live_recent ON nodes(label, last_updated_at DESC) WHERE valid_to IS NULL;
+-- Problems by recency (the only label read newest-first). Over every live row,
+-- each write that stamps last_updated_at moved a code symbol's entry from a
+-- scattered leaf: ~19 KB per position-only symbol rewrite on a 1.1 GB store.
+-- label stays the leading column so label = 'Problem' plans without a sort.
+DROP INDEX IF EXISTS nodes_live_recent;
+CREATE INDEX IF NOT EXISTS nodes_live_problem_recent ON nodes(label, last_updated_at DESC) WHERE valid_to IS NULL AND label = 'Problem';
 -- "Anything created since the watermark?" guards (the fold, regression and
 -- canonical-bind sweeps run one per session boundary). Without it the planner
 -- walks nodes_live and reads every live row of the label to test created_at:
@@ -27378,24 +27383,34 @@ CREATE INDEX IF NOT EXISTS nodes_closed_relpath ON nodes(json_extract(attrs_json
 -- Live rows by name, for looking up the few symbols a statement mentions
 -- instead of hydrating every code symbol per minted problem.
 CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) WHERE valid_to IS NULL;
+-- The six single-attr lookups below are partial on the attr being present: each
+-- is read only by equality (or IN), which implies it. Keyed on NULL for the ~95%
+-- of rows that lack the attr, every write to such a row's attrs rewrote its NULL
+-- entry: ~25 KB per position-only symbol rewrite on a 1.1 GB store (2026-10-21).
+DROP INDEX IF EXISTS nodes_anchor_hint_path;
+DROP INDEX IF EXISTS nodes_command_signature;
+DROP INDEX IF EXISTS nodes_diag_command;
+DROP INDEX IF EXISTS nodes_lsp_rel_path;
+DROP INDEX IF EXISTS nodes_cloud_node_id;
+DROP INDEX IF EXISTS nodes_enrichment_pending;
 -- Problems by the file their anchor hint names: the harvest upgrades hints for
 -- every edited file of every turn, and a scan parses every Problem's attrs.
-CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path ON nodes(json_extract(attrs_json, '$.anchorHint.path')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path_v2 ON nodes(json_extract(attrs_json, '$.anchorHint.path')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.anchorHint.path') IS NOT NULL;
 -- Problems by the command / checker / file that opened them. The generalizer
 -- looked these up per shell or tool EVENT by hydrating every Problem: ~12s of
 -- every minute of daemon main-thread time on a 3.4k-Problem store (2026-10-05).
-CREATE INDEX IF NOT EXISTS nodes_command_signature ON nodes(json_extract(attrs_json, '$.commandSignature')) WHERE valid_to IS NULL;
-CREATE INDEX IF NOT EXISTS nodes_diag_command ON nodes(json_extract(attrs_json, '$.diagCommand')) WHERE valid_to IS NULL;
-CREATE INDEX IF NOT EXISTS nodes_lsp_rel_path ON nodes(json_extract(attrs_json, '$.lspRelPath')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_command_signature_v2 ON nodes(json_extract(attrs_json, '$.commandSignature')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.commandSignature') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_diag_command_v2 ON nodes(json_extract(attrs_json, '$.diagCommand')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.diagCommand') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_lsp_rel_path_v2 ON nodes(json_extract(attrs_json, '$.lspRelPath')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.lspRelPath') IS NOT NULL;
 -- Local nodes by the cloud twin their upload receipt recorded. Every burst /
 -- search fusion folds the Network copy of the caller's own knowledge back onto
 -- the local node; unindexed, the reverse lookup was a ~300ms attrs scan per call.
-CREATE INDEX IF NOT EXISTS nodes_cloud_node_id ON nodes(json_extract(attrs_json, '$.cloudNodeId')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_cloud_node_id_v2 ON nodes(json_extract(attrs_json, '$.cloudNodeId')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.cloudNodeId') IS NOT NULL;
 -- Nodes still waiting on a root-cause ask. The MCP server checks this on EVERY
 -- tool response (the enrichment piggyback), so it must not parse every
--- Solution's and Problem's attrs per call. Not partial: the Problem pull reads
+-- Solution's and Problem's attrs per call. Any version: the Problem pull reads
 -- closed versions too.
-CREATE INDEX IF NOT EXISTS nodes_enrichment_pending ON nodes(json_extract(attrs_json, '$.enrichmentPending'));
+CREATE INDEX IF NOT EXISTS nodes_enrichment_pending_v2 ON nodes(json_extract(attrs_json, '$.enrichmentPending')) WHERE json_extract(attrs_json, '$.enrichmentPending') IS NOT NULL;
 -- Revisit flags, any label, any version: listNeedsRevisit's as-of read runs on
 -- every context render and otherwise json-checks every row (10.3 s on a 324k-row
 -- store, to return zero flags). The predicate must stay textually identical to
@@ -27461,6 +27476,30 @@ function rowToEdge(r) {
 }
 var FINGERPRINT_INDEXED_LABELS = ["Problem", "Vulnerability", "Solution", "RootCause"];
 var NODE_LABELS_CHUNK = 256;
+var NODE_UPSERT_COLUMNS = [
+  "label",
+  "description",
+  "extraction_confidence",
+  "embedding_json",
+  "embedding_blob",
+  "cumulative_surprise",
+  "peak_surprise",
+  "cumulative_hits",
+  "last_updated_at",
+  "memory_tier",
+  "page_rank",
+  "is_landmark",
+  "community",
+  "stability",
+  "last_reinforced_at_seq",
+  "attrs_json"
+];
+var EDGE_UPSERT_COLUMNS = ["confidence", "last_seen_at", "nav_successes", "nav_failures", "valid_to", "attrs_json"];
+function sameSqlValue(a, b) {
+  if (a === b || a == null && b == null) return true;
+  if (a instanceof Uint8Array && b instanceof Uint8Array) return Buffer.compare(a, b) === 0;
+  return false;
+}
 var PRIOR_TAG_MARKER = '"priorTag":true';
 var SqliteGraphStore = class {
   db;
@@ -27468,6 +27507,8 @@ var SqliteGraphStore = class {
   // used to prepare it on every call: ~600ms of a 2.5s drain build on a live
   // 225k-node store was statement compilation alone. Keyed by the SQL text.
   typedEdgeStmts = /* @__PURE__ */ new Map();
+  /** Narrow merge updates, keyed by table and the columns they set. */
+  changedColumnStmts = /* @__PURE__ */ new Map();
   stmts;
   /** Unified graph-mutation counter (see GraphStore.mutationCount). Bumped on
    *  every node/edge upsert — code-index and capture alike — so the consolidation
@@ -27551,6 +27592,8 @@ var SqliteGraphStore = class {
           last_reinforced_at_seq = excluded.last_reinforced_at_seq,
           attrs_json = excluded.attrs_json
       `),
+      nodeUpsertTarget: this.db.prepare(`SELECT rowid AS rid, ${NODE_UPSERT_COLUMNS.join(", ")} FROM nodes WHERE id = ?`),
+      edgeUpsertTarget: this.db.prepare(`SELECT rowid AS rid, ${EDGE_UPSERT_COLUMNS.join(", ")} FROM edges WHERE from_id = ? AND type = ? AND to_id = ?`),
       getNode: this.db.prepare("SELECT nodes.*, (SELECT x.attrs_json FROM node_exposure x WHERE x.id = nodes.id) AS exposure_json FROM nodes WHERE id = ?"),
       exposureOf: this.db.prepare("SELECT attrs_json FROM node_exposure WHERE id = ?"),
       writeExposure: this.db.prepare("INSERT INTO node_exposure(id, attrs_json) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET attrs_json = excluded.attrs_json"),
@@ -27919,7 +27962,7 @@ var SqliteGraphStore = class {
   }
   mergeNode(node) {
     this.mutations++;
-    this.stmts.insertNode.run({
+    const values = {
       id: node.id,
       label: node.label,
       description: node.description,
@@ -27946,7 +27989,23 @@ var SqliteGraphStore = class {
       created_at_seq: node.createdAtSeq ?? null,
       last_reinforced_at_seq: node.lastReinforcedAtSeq ?? null,
       attrs_json: this.nodeAttrsJson(node.id, node.attrs ?? {})
-    });
+    };
+    const current = this.stmts.nodeUpsertTarget.get(node.id);
+    if (current) this.writeChangedColumns("nodes", NODE_UPSERT_COLUMNS, current, values);
+    else this.stmts.insertNode.run(values);
+  }
+  /** What the upsert's ON CONFLICT would write over `current`, setting only the
+   *  columns whose value moves (NODE_UPSERT_COLUMNS says why). */
+  writeChangedColumns(table, columns2, current, next) {
+    const changed = columns2.filter((c) => !sameSqlValue(current[c], next[c]));
+    if (changed.length === 0) return;
+    const key = `${table}:${changed.join(",")}`;
+    let stmt2 = this.changedColumnStmts.get(key);
+    if (!stmt2) {
+      stmt2 = this.db.prepare(`UPDATE ${table} SET ${changed.map((c) => `${c} = :${c}`).join(", ")} WHERE rowid = :rid`);
+      this.changedColumnStmts.set(key, stmt2);
+    }
+    stmt2.run({ rid: current["rid"], ...Object.fromEntries(changed.map((c) => [c, next[c]])) });
   }
   /** mergeNode, unless the live row already holds this content. Content is what
    *  the columns a merge rewrites from the producer (label, description, attrs,
@@ -28080,7 +28139,7 @@ var SqliteGraphStore = class {
       return;
     }
     this.mutations++;
-    this.stmts.insertEdge.run({
+    const values = {
       id: edge.id,
       from_id: edge.from,
       to_id: edge.to,
@@ -28094,6 +28153,16 @@ var SqliteGraphStore = class {
       valid_from: edge.validFrom ?? edge.createdAt,
       valid_to: edge.validTo ?? null,
       attrs_json: JSON.stringify(edge.attrs ?? {})
+    };
+    const current = this.stmts.edgeUpsertTarget.get(edge.from, edge.type, edge.to);
+    if (!current) {
+      this.stmts.insertEdge.run(values);
+      return;
+    }
+    this.writeChangedColumns("edges", EDGE_UPSERT_COLUMNS, current, {
+      ...values,
+      confidence: Math.max(current["confidence"], edge.confidence),
+      valid_to: null
     });
   }
   /** mergeEdge, unless the live edge already holds this content: same attrs, and
@@ -28308,8 +28377,8 @@ var SqliteGraphStore = class {
       after = rows[rows.length - 1].rid;
     }
   }
-  recentNodeIds(label, limit) {
-    const rows = this.db.prepare("SELECT id FROM nodes WHERE label = ? AND valid_to IS NULL ORDER BY last_updated_at DESC LIMIT ?").all(label, Math.max(0, limit));
+  recentProblemIds(limit) {
+    const rows = this.db.prepare("SELECT id FROM nodes WHERE label = 'Problem' AND valid_to IS NULL ORDER BY last_updated_at DESC LIMIT ?").all(Math.max(0, limit));
     return rows.map((r) => r.id);
   }
   recentOpenProblemCandidates(opts) {
@@ -28750,7 +28819,7 @@ var SqliteGraphStore = class {
       const slice = cloudIds.slice(i2, i2 + CHUNK);
       if (slice.length === 0) continue;
       const rows = this.db.prepare(
-        `SELECT id, json_extract(attrs_json, '$.cloudNodeId') AS cloud FROM nodes INDEXED BY nodes_cloud_node_id WHERE json_extract(attrs_json, '$.cloudNodeId') IN (${slice.map(() => "?").join(",")}) AND valid_to IS NULL ORDER BY id`
+        `SELECT id, json_extract(attrs_json, '$.cloudNodeId') AS cloud FROM nodes INDEXED BY nodes_cloud_node_id_v2 WHERE json_extract(attrs_json, '$.cloudNodeId') IN (${slice.map(() => "?").join(",")}) AND valid_to IS NULL ORDER BY id`
       ).all(...slice);
       for (const r of rows) out2.set(r.cloud, [...out2.get(r.cloud) ?? [], r.id]);
     }

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

@@ -1,6 +1,6 @@
 {
   "name": "errata-context",
-  "version": "2.0.22-dev.4676",
+  "version": "2.0.23-dev.4682",
   "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 @@
-aed45b59cddfbffc63052b049122c7b5303eb3f921379af8ac2e969ded158d58  .codex-plugin/plugin.json
+51434f3e703060bee5abb7c7eebe1446b66132c9cb7e43ae630daf855d83bc02  .codex-plugin/plugin.json
 a7bebae9fb01c838d6c75fc784129e28be571233fa66ff5ee8039b574f35ccf7  assets/icon.png
 fc38b64e4df1e0b72c35764bef6c4c05430d97c9009ad0ecc8a9e75b4deab232  configure-local.mjs
 73dc6028b3b070257c7c31f252d11e55a9e096f4aed0f187f10cb21716e1e6d7  dist/client.js