@inerrata-corporation/errata 2.0.22-dev.4665 → 2.0.22-dev.4676

package/consolidate-worker.mjs

@@ -16825,6 +16825,48 @@ 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/exposure-attrs.ts
+var EXPOSURE_ATTRS = [
+  "shownCount",
+  "evictedCount",
+  "firstShownAt",
+  "firstEvictedAt",
+  "firstShownAtSeq",
+  "lastShownAtSeq",
+  "lastEvictedAtSeq",
+  "shownSinceTouch",
+  "shownSinceTouchAt",
+  "exposureLog",
+  "exposureLogStart",
+  "exposureLogSince",
+  "exposureFirst",
+  "exposureTrimmed"
+];
+var EXPOSURE_SCOPE = "exposure";
+var EXPOSURE_KEYS = new Set(EXPOSURE_ATTRS);
+var isExposureAttr = (key) => EXPOSURE_KEYS.has(key);
+function pickExposure(attrs) {
+  const out = {};
+  for (const k of EXPOSURE_ATTRS) if (attrs[k] !== void 0) out[k] = attrs[k];
+  return out;
+}
+function exposureDocSql(key) {
+  return `coalesce((SELECT x.attrs_json FROM node_exposure x WHERE x.id = nodes.id AND json_type(x.attrs_json, '$.${key}') IS NOT NULL), attrs_json)`;
+}
+
 // ../../packages/local-graph/src/history-cache-floor.ts
 var HISTORY_CACHE_FLOOR_KEY = "history-cache-withdrawal-floor-3";
 function installHistoryCacheFloor(db) {
@@ -17109,25 +17151,6 @@ function textIndexReady(db) {
   return db.prepare("SELECT value FROM store_meta WHERE key = ?").get(TEXT_INDEX_KEY)?.["value"] === "installed";
 }
 
-// ../../packages/local-graph/src/exposure-attrs.ts
-var EXPOSURE_ATTRS = [
-  "shownCount",
-  "evictedCount",
-  "firstShownAt",
-  "firstEvictedAt",
-  "firstShownAtSeq",
-  "lastShownAtSeq",
-  "lastEvictedAtSeq",
-  "shownSinceTouch",
-  "shownSinceTouchAt",
-  "exposureLog",
-  "exposureLogStart",
-  "exposureLogSince",
-  "exposureFirst",
-  "exposureTrimmed"
-];
-var EXPOSURE_SCOPE = "exposure";
-
 // ../../packages/local-graph/src/change-feed.ts
 var CHANGE_FEED_KEY = "change-feed";
 var ANY_CHANGE = "*";
@@ -17191,6 +17214,16 @@ function readChangedNodeIds(db, sinceSeq, labels) {
   const rows = db.prepare(`SELECT DISTINCT id FROM change_log WHERE change_seq > ? AND kind = 'node' AND label IN (${labels.map(() => "?").join(",")})`).all(sinceSeq, ...labels);
   return rows.map((r) => r.id);
 }
+function readChangedAmong(db, sinceSeq, ids) {
+  if (!changeLogCovers(db, sinceSeq)) return null;
+  const out = [];
+  for (let i = 0; i < ids.length; i += 500) {
+    const chunk = ids.slice(i, i + 500);
+    const rows = db.prepare(`SELECT DISTINCT id FROM change_log WHERE change_seq > ? AND kind = 'node' AND id IN (${chunk.map(() => "?").join(",")})`).all(sinceSeq, ...chunk);
+    for (const r of rows) out.push(r.id);
+  }
+  return out;
+}
 function readLineageChangedFiles(db, sinceSeq) {
   if (!changeLogCovers(db, sinceSeq)) return null;
   const rows = db.prepare(LINEAGE_CHANGED_FILES_SQL).all({ s: sinceSeq });
@@ -17665,8 +17698,11 @@ function compileNodeWhere(q) {
   }
   return { where: conds.join(" AND "), params };
 }
-function attrValueSql(p) {
-  return `CASE json_type(attrs_json, ${p}) WHEN 'integer' THEN CAST(json_extract(attrs_json, ${p}) AS REAL) ELSE json_extract(attrs_json, ${p}) END`;
+function attrValueSql(p, doc = "attrs_json") {
+  return `CASE json_type(${doc}, ${p}) WHEN 'integer' THEN CAST(json_extract(${doc}, ${p}) AS REAL) ELSE json_extract(${doc}, ${p}) END`;
+}
+function attrDocSql(key) {
+  return isExposureAttr(key) ? exposureDocSql(key) : "attrs_json";
 }
 function nodeSelectFrom(q) {
   if (q.indexedBy) return `nodes INDEXED BY ${selectIndex(q.indexedBy)}`;
@@ -17679,7 +17715,7 @@ function nodeSelectFrom(q) {
 function compileNodeSelect(q) {
   const { where, params } = compileNodeWhere(q);
   const attrs = q.attrs ?? [];
-  const attrCols = attrs.map((k, i) => `, ${attrValueSql(path(k))} AS a${i}, json_type(attrs_json, ${path(k)}) AS t${i}`).join("");
+  const attrCols = attrs.map((k, i) => `, ${attrValueSql(path(k), attrDocSql(k))} AS a${i}, json_type(${attrDocSql(k)}, ${path(k)}) AS t${i}`).join("");
   let order;
   if (q.orderBy && "column" in q.orderBy) {
     order = `${column(q.orderBy.column)} ${q.orderBy.desc ? "DESC" : "ASC"}, rowid`;
@@ -17796,6 +17832,7 @@ function localEdgeViolation(fromLabel, type, toLabel) {
 }
 var SCHEMA_VERSION = 6;
 var SESSION_REPAIR_KEY = "session-evidence-v1";
+var EXPOSURE_SIDE_KEY = "exposure-side-rows-1";
 var SESSION_EVIDENCE_PREDICATE = SESSION_EVIDENCE_FIELDS.map((field) => `instr(attrs_json, '${JSON.stringify(field)}') > 0`).join(" OR ");
 var SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS schema_version (
@@ -17859,8 +17896,13 @@ CREATE TABLE IF NOT EXISTS nodes (
 );
 
 CREATE INDEX IF NOT EXISTS nodes_label ON nodes(label);
-CREATE INDEX IF NOT EXISTS nodes_memory_tier ON nodes(memory_tier);
-CREATE INDEX IF NOT EXISTS nodes_page_rank ON nodes(page_rank DESC);
+-- Dropped: no query plans through them (every prepared statement across the
+-- local-graph, indexer, context-writer, generalizer and daemon suites was
+-- planned with and without them, 2026-10-21), and each write that touches
+-- memory_tier / page_rank (every node upsert, every rescore) paid to maintain
+-- them. nodes_live_page_rank serves the live page-rank orderings.
+DROP INDEX IF EXISTS nodes_memory_tier;
+DROP INDEX IF EXISTS nodes_page_rank;
 
 CREATE TABLE IF NOT EXISTS edges (
   id TEXT PRIMARY KEY,
@@ -17882,7 +17924,10 @@ CREATE TABLE IF NOT EXISTS edges (
   FOREIGN KEY (to_id) REFERENCES nodes(id) ON DELETE CASCADE
 );
 
-CREATE INDEX IF NOT EXISTS edges_from ON edges(from_id, type);
+-- Dropped: a prefix of edges_triple (from_id, type, to_id), which every
+-- from-side lookup and foreign-key check already plans through; it cost 47 MB
+-- and an index write on every edge write.
+DROP INDEX IF EXISTS edges_from;
 CREATE INDEX IF NOT EXISTS edges_to ON edges(to_id, type);
 CREATE INDEX IF NOT EXISTS edges_type ON edges(type);
 CREATE UNIQUE INDEX IF NOT EXISTS edges_triple ON edges(from_id, type, to_id);
@@ -17904,6 +17949,12 @@ 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;
+-- Render impressions, one row per node id (exposure-attrs.ts): a render bumps
+-- ~40 of these, which in the node row rewrote each whole row and its indexes.
+CREATE TABLE IF NOT EXISTS node_exposure (
+  id TEXT PRIMARY KEY,
+  attrs_json TEXT NOT NULL DEFAULT '{}'
+) WITHOUT ROWID;
 -- 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).
@@ -17911,6 +17962,9 @@ CREATE INDEX IF NOT EXISTS nodes_live_resolved ON nodes(label, valid_to) WHERE v
 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
@@ -18064,6 +18118,7 @@ var SqliteGraphStore = class {
   constructor(opts) {
     this.db = openDatabase(opts.path);
     this.db.exec("PRAGMA cache_size = -32768");
+    this.db.exec("PRAGMA mmap_size = 2147483648");
     this.db.exec(SCHEMA_SQL);
     const versionRow = this.db.prepare("SELECT version FROM schema_version LIMIT 1").get();
     if (!versionRow) {
@@ -18127,8 +18182,17 @@ var SqliteGraphStore = class {
           last_reinforced_at_seq = excluded.last_reinforced_at_seq,
           attrs_json = excluded.attrs_json
       `),
-      getNode: this.db.prepare("SELECT * FROM nodes WHERE 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"),
+      lastUpdatedOf: this.db.prepare("SELECT last_updated_at AS t, attrs_json 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).
@@ -18285,6 +18349,7 @@ var SqliteGraphStore = class {
         "INSERT INTO store_meta (key, value) VALUES ('ingest_seq', :v) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
       )
     };
+    this.moveExposureToSideRows();
     const seqRow = this.db.prepare("SELECT value FROM store_meta WHERE key = 'ingest_seq'").get();
     this.ingestSeq = seqRow ? Number(seqRow.value) : 0;
   }
@@ -18340,6 +18405,41 @@ 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 exposed = this.db.prepare(
+      `SELECT n.rowid AS rid, n.logical_id, n.version, n.valid_to, n.label, x.attrs_json AS exposure
+         FROM node_exposure x JOIN nodes n ON n.id = x.id`
+    ).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}
+                                 UNION SELECT n2.logical_id FROM node_exposure x2 JOIN nodes n2 ON n2.id = x2.id)
+         EXCEPT SELECT rowid FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE}
+         EXCEPT SELECT n3.rowid FROM node_exposure x3 JOIN nodes n3 ON n3.id = x3.id)`
+    ).all();
+    const byRid = /* @__PURE__ */ new Map();
+    for (const r of [...counted, ...others]) {
+      const attrs = {};
+      WM_CALIBRATION_KEYS.forEach((k, i) => {
+        const v = r[`c${i}`];
+        if (typeof v === "number") attrs[k] = v;
+      });
+      byRid.set(r.rid, { row: r, attrs });
+    }
+    for (const r of exposed) {
+      const side = JSON.parse(r.exposure);
+      const entry = byRid.get(r.rid) ?? { row: r, attrs: {} };
+      for (const k of WM_CALIBRATION_KEYS) if (typeof side[k] === "number" && Number.isFinite(side[k])) entry.attrs[k] = side[k];
+      byRid.set(r.rid, entry);
+    }
+    const order = new Map(labels.map((l, i) => [l, i]));
+    return [...byRid.values()].filter(({ row }) => order.has(row.label)).sort((a, b) => order.get(a.row.label) - order.get(b.row.label) || a.row.rid - b.row.rid).map(({ row, attrs }) => ({ logicalId: row.logical_id, version: Number(row.version), validTo: row.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
@@ -18476,9 +18576,22 @@ var SqliteGraphStore = class {
       logical_id: node.logicalId ?? node.id,
       created_at_seq: node.createdAtSeq ?? null,
       last_reinforced_at_seq: node.lastReinforcedAtSeq ?? null,
-      attrs_json: JSON.stringify(node.attrs ?? {})
+      attrs_json: this.nodeAttrsJson(node.id, 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 && !EXPOSURE_ATTRS.some((k) => node.attrs?.[k] !== void 0) && 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({
@@ -18502,7 +18615,37 @@ var SqliteGraphStore = class {
       logical_id: patch.logicalId ?? null,
       created_at_seq: patch.createdAtSeq ?? null,
       last_reinforced_at_seq: patch.lastReinforcedAtSeq ?? null,
-      attrs_json: patch.attrs ? JSON.stringify(patch.attrs) : null
+      attrs_json: patch.attrs ? this.nodeAttrsJson(id, patch.attrs) : null
+    });
+  }
+  /**
+   * The node-row attrs of a write, after handing any exposure keys to the side
+   * row (exposure-attrs.ts). `getNode` returns exposure merged into attrs, so a
+   * read-modify-write carries it; kept in the row it would re-bloat the row and
+   * drift from the side row. Unchanged exposure costs no write.
+   */
+  nodeAttrsJson(id, attrs) {
+    if (!EXPOSURE_ATTRS.some((k) => attrs[k] !== void 0)) return JSON.stringify(attrs);
+    const current = this.stmts.exposureOf.get(id);
+    const next = JSON.stringify({ ...current ? JSON.parse(current.attrs_json) : {}, ...pickExposure(attrs) });
+    if (current?.attrs_json !== next) this.stmts.writeExposure.run(id, next);
+    const rest = { ...attrs };
+    for (const k of EXPOSURE_ATTRS) delete rest[k];
+    return JSON.stringify(rest);
+  }
+  /** One-time: exposure keys written to node rows before the side table existed
+   *  move to it. Only rows carrying a counter can carry exposure, and those are
+   *  what nodes_wm_counted holds, so this reads the index, not the table. */
+  moveExposureToSideRows() {
+    if (this.db.prepare("SELECT value FROM store_meta WHERE key = ?").get(EXPOSURE_SIDE_KEY)) return;
+    const rows = this.db.prepare(`SELECT id, attrs_json FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE}`).all();
+    const move = this.db.prepare("UPDATE nodes SET attrs_json = ? WHERE id = ?");
+    this.db.transaction(() => {
+      for (const r of rows) {
+        const stripped = this.nodeAttrsJson(r.id, JSON.parse(r.attrs_json));
+        if (stripped !== r.attrs_json) move.run(stripped, r.id);
+      }
+      this.db.prepare("INSERT OR REPLACE INTO store_meta(key, value) VALUES (?, 'done')").run(EXPOSURE_SIDE_KEY);
     });
   }
   /** Fast single-column writes for the nightly pass (avoid the 18-column COALESCE
@@ -18584,6 +18727,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
@@ -18650,7 +18808,27 @@ var SqliteGraphStore = class {
   }
   getNode(id) {
     const row = this.stmts.getNode.get(id);
-    return row ? rowToNode(row) : null;
+    if (!row) return null;
+    const node = rowToNode(row);
+    if (row.exposure_json) Object.assign(node.attrs, JSON.parse(row.exposure_json));
+    return node;
+  }
+  /** A node's render exposure: the side row's keys over the node row's own
+   *  (exposure-attrs.ts), plus the node's `lastUpdatedAt` (the "shown since
+   *  touch" counter is relative to it) — without reading the node's attrs. */
+  exposureOf(id) {
+    const row = this.stmts.lastUpdatedOf.get(id);
+    if (!row) return null;
+    const side = this.stmts.exposureOf.get(id);
+    return {
+      attrs: { ...pickExposure(JSON.parse(row.attrs_json)), ...side ? JSON.parse(side.attrs_json) : {} },
+      lastUpdatedAt: row.t
+    };
+  }
+  /** Replace a node's exposure (only EXPOSURE_ATTRS keys belong here). Touches
+   *  neither the node row nor its indexes, nor the change feed. */
+  writeExposure(id, attrs) {
+    this.stmts.writeExposure.run(id, JSON.stringify(attrs));
   }
   nodeLabels(ids) {
     const width = NODE_LABELS_CHUNK;
@@ -18701,7 +18879,7 @@ var SqliteGraphStore = class {
   findNodeStampsByLabel(label, attrKey) {
     if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(attrKey)) throw new Error(`findNodeStampsByLabel: bad attr key ${attrKey}`);
     const rows = this.db.prepare(
-      `SELECT id, created_at, created_at_seq, json_type(attrs_json, '$.${attrKey}') IS NOT NULL AS has,
+      `SELECT id, created_at, created_at_seq, json_type(${attrDocSql(attrKey)}, '$.${attrKey}') IS NOT NULL AS has,
                 COALESCE(json_extract(attrs_json, '$.source') = 'cloud', 0) AS cloud
            FROM nodes WHERE label = ? AND valid_to IS NULL`
     ).all(label);
@@ -18718,7 +18896,7 @@ var SqliteGraphStore = class {
     const keys = [...new Set(attrKeys)];
     const rows = this.db.prepare(
       `SELECT id, created_at, created_at_seq,
-                ${keys.map((k, i) => `json_type(attrs_json, '$.${k}') IS NOT NULL AS h${i}`).join(", ")}${keys.length ? "," : ""}
+                ${keys.map((k, i) => `json_type(${attrDocSql(k)}, '$.${k}') IS NOT NULL AS h${i}`).join(", ")}${keys.length ? "," : ""}
                 COALESCE(json_extract(attrs_json, '$.source') = 'cloud', 0) AS cloud
            FROM nodes WHERE label = ? AND valid_to IS NULL`
     ).all(label);
@@ -18978,6 +19156,9 @@ var SqliteGraphStore = class {
   changedNodeIds(sinceSeq, labels) {
     return readChangedNodeIds(this.db, sinceSeq, labels);
   }
+  changedAmong(sinceSeq, ids) {
+    return readChangedAmong(this.db, sinceSeq, ids);
+  }
   pruneChangeLog() {
     return pruneChangeLog(this.db);
   }