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

package/pass-worker.mjs

@@ -17450,10 +17450,20 @@ function isReExportBarrel(relPath) {
 function graphExportMap(store2, workspaceId, relPath) {
   const out2 = /* @__PURE__ */ new Map();
   const fileId = fileNodeId(workspaceId, relPath);
-  if (!store2.getNode(fileId)) return out2;
-  for (const e of store2.outEdges(fileId, ["DEFINES"])) {
-    const n = store2.getNode(e.to);
-    if (!n || !EXPORTABLE_LABELS.has(n.label)) continue;
+  if (store2.nodeLabels([fileId]).size === 0) return out2;
+  const defines = store2.outEdges(fileId, ["DEFINES"]);
+  const rows = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < defines.length; i2 += 500) {
+    for (const r of store2.selectNodes({
+      labels: [...EXPORTABLE_LABELS],
+      attrs: ["workspaceId", "name"],
+      where: [{ idIn: defines.slice(i2, i2 + 500).map((e) => e.to) }],
+      includeClosed: true
+    })) rows.set(r.id, r);
+  }
+  for (const e of defines) {
+    const n = rows.get(e.to);
+    if (!n) continue;
     if (n.attrs["workspaceId"] !== workspaceId) continue;
     const name2 = n.attrs["name"] ?? n.description;
     if (!name2 || name2.startsWith("<") || name2.includes(":")) continue;
@@ -17629,7 +17639,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 +17678,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 +25873,110 @@ 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/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 out2 = {};
+  for (const k of EXPOSURE_ATTRS) if (attrs[k] !== void 0) out2[k] = attrs[k];
+  return out2;
+}
+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) {
@@ -26126,25 +26261,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 = "*";
@@ -26208,6 +26324,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 out2 = [];
+  for (let i2 = 0; i2 < ids.length; i2 += 500) {
+    const chunk = ids.slice(i2, i2 + 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) out2.push(r.id);
+  }
+  return out2;
+}
 function readLineageChangedFiles(db, sinceSeq) {
   if (!changeLogCovers(db, sinceSeq)) return null;
   const rows = db.prepare(LINEAGE_CHANGED_FILES_SQL).all({ s: sinceSeq });
@@ -26941,8 +27067,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)}`;
@@ -26955,7 +27084,7 @@ function nodeSelectFrom(q) {
 function compileNodeSelect(q) {
   const { where, params } = compileNodeWhere(q);
   const attrs = q.attrs ?? [];
-  const attrCols = attrs.map((k, i2) => `, ${attrValueSql(path(k))} AS a${i2}, json_type(attrs_json, ${path(k)}) AS t${i2}`).join("");
+  const attrCols = attrs.map((k, i2) => `, ${attrValueSql(path(k), attrDocSql(k))} AS a${i2}, json_type(${attrDocSql(k)}, ${path(k)}) AS t${i2}`).join("");
   let order;
   if (q.orderBy && "column" in q.orderBy) {
     order = `${column(q.orderBy.column)} ${q.orderBy.desc ? "DESC" : "ASC"}, rowid`;
@@ -27072,6 +27201,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 (
@@ -27135,8 +27265,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,
@@ -27158,7 +27293,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);
@@ -27180,6 +27318,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).
@@ -27187,6 +27331,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
@@ -27340,6 +27487,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) {
@@ -27403,8 +27551,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).
@@ -27561,6 +27718,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;
   }
@@ -27616,6 +27774,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, i2) => `${wmCounterSql(k)} AS c${i2}`).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, i2) => {
+        const v = r[`c${i2}`];
+        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, i2) => [l, i2]));
+    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(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
@@ -27752,9 +27945,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({
@@ -27778,7 +27984,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
@@ -27860,6 +28096,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
@@ -27926,7 +28177,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;
@@ -27977,7 +28248,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);
@@ -27994,7 +28265,7 @@ var SqliteGraphStore = class {
     const keys = [...new Set(attrKeys)];
     const rows = this.db.prepare(
       `SELECT id, created_at, created_at_seq,
-                ${keys.map((k, i2) => `json_type(attrs_json, '$.${k}') IS NOT NULL AS h${i2}`).join(", ")}${keys.length ? "," : ""}
+                ${keys.map((k, i2) => `json_type(${attrDocSql(k)}, '$.${k}') IS NOT NULL AS h${i2}`).join(", ")}${keys.length ? "," : ""}
                 COALESCE(json_extract(attrs_json, '$.source') = 'cloud', 0) AS cloud
            FROM nodes WHERE label = ? AND valid_to IS NULL`
     ).all(label);
@@ -28254,6 +28525,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);
   }
@@ -30415,76 +30689,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();
@@ -31013,6 +31217,91 @@ var AGENTS_POINTER_BODY = [
 // ../../packages/context-writer/src/render.ts
 init_src2();
 init_src();
+
+// ../../packages/context-writer/src/snapshot-inputs.ts
+var SNAPSHOT_NODE_LABELS = [
+  "Problem",
+  "Vulnerability",
+  "Solution",
+  "Pattern",
+  "Technique",
+  "AntiPattern",
+  "Language",
+  "Package",
+  "Tool"
+];
+var SNAPSHOT_EDGE_TYPES = [
+  "ANCHORED_AT",
+  "CAUSED_BY",
+  "CONCERNS",
+  "DEPENDS_ON",
+  "EVIDENCED_BY",
+  "MANIFESTED_IN",
+  "OCCURS_IN",
+  "PERTAIN_TO",
+  "REGRESSION_OF",
+  "SOLVED_BY"
+];
+var SNAPSHOT_READ_GUARD = typeof process !== "undefined" && Boolean(process.env["VITEST"]);
+var LABELS = new Set(SNAPSHOT_NODE_LABELS);
+var EDGES = new Set(SNAPSHOT_EDGE_TYPES);
+function guardSnapshotReads(store2) {
+  const fail = (what) => {
+    throw new Error(`buildSnapshot read ${what}, outside SNAPSHOT_NODE_LABELS/SNAPSHOT_EDGE_TYPES (snapshot-inputs.ts)`);
+  };
+  const label = (l, via) => {
+    if (typeof l === "string" && !LABELS.has(l)) fail(`label ${l} via ${via}`);
+  };
+  const types = (t, via) => {
+    if (!Array.isArray(t) || t.length === 0) fail(`every edge type via ${via}`);
+    for (const x of t) if (!EDGES.has(String(x))) fail(`edge type ${String(x)} via ${via}`);
+  };
+  const nodes = (r, via) => {
+    for (const n of Array.isArray(r) ? r : r ? [r] : []) label(n.label, via);
+    return r;
+  };
+  const allowed = {
+    getNode: (id) => nodes(store2.getNode(id), "getNode"),
+    selectNodes: (q) => {
+      for (const l of q.labels) label(l, "selectNodes");
+      return store2.selectNodes(q);
+    },
+    countNodes: (q) => {
+      for (const l of q.labels) label(l, "countNodes");
+      return store2.countNodes(q);
+    },
+    findLiveNodesByAttr: (l, ...rest) => {
+      label(l, "findLiveNodesByAttr");
+      return store2.findLiveNodesByAttr(l, ...rest);
+    },
+    outEdges: (id, t) => {
+      types(t, "outEdges");
+      return store2.outEdges(id, t);
+    },
+    inEdges: (id, t) => {
+      types(t, "inEdges");
+      return store2.inEdges(id, t);
+    },
+    inDegreeByType: (t) => {
+      types(t, "inDegreeByType");
+      return store2.inDegreeByType(t);
+    },
+    nodesAsOfWhereTrue: (asOf, attr) => {
+      if (attr !== "revisit") fail(`nodesAsOfWhereTrue(${String(attr)})`);
+      return store2.nodesAsOfWhereTrue(asOf, attr);
+    }
+  };
+  return new Proxy(store2, {
+    get(target, prop) {
+      if (typeof prop === "string" && prop in allowed) return allowed[prop];
+      const v = Reflect.get(target, prop, target);
+      if (typeof v === "function") return () => fail(`store.${String(prop)}()`);
+      return v;
+    }
+  });
+}
+
+// ../../packages/context-writer/src/render.ts
 var MOTIF_BAND = 10;
 var MOTIF_POOL = 1e3;
 function rankMotifs(pool, signal, k = MOTIF_BAND) {
@@ -31033,6 +31322,8 @@ var PROBLEM_BAND_ATTRS = [
   ...HISTORY_POLICY_ATTRS
 ];
 function buildSnapshot(opts) {
+  const codeStore = opts.store;
+  if (SNAPSHOT_READ_GUARD) opts = { ...opts, store: guardSnapshotReads(opts.store) };
   const hydrate = (id) => opts.store.getNode(id);
   const problems = opts.store.selectNodes({ labels: ["Problem", "Vulnerability"], attrs: PROBLEM_BAND_ATTRS }).filter((p) => p.attrs["mergedInto"] === void 0 && passiveAllowed(p, opts.atCommit));
   const stillOpen = problems.filter((p) => p.attrs["resolvedAt"] == null);
@@ -31068,7 +31359,7 @@ function buildSnapshot(opts) {
   const recentResolved = resolvedPool.slice(0, RECENT_RESOLVED);
   const motifPool = opts.store.selectNodes({ labels: ["Pattern", "Technique", "AntiPattern"], attrs: ["missedRuns", ...HISTORY_POLICY_ATTRS] }).filter((n) => passiveAllowed(n, opts.atCommit)).filter((n) => !(Number(n.attrs["missedRuns"] ?? 0) > 0)).sort((a, b) => b.pageRank - a.pageRank).slice(0, MOTIF_POOL).map((r) => hydrate(r.id)).map((n) => n.embedding.length > 0 ? { ...n, embedding: [] } : n);
   const motifs = rankMotifs(motifPool, void 0);
-  const workingFile = opts.workingFile ? sliceForFile(opts.store, opts.workingFile, opts.atCommit) : void 0;
+  const workingFile = opts.workingFile ? sliceForFile(codeStore, opts.workingFile, opts.atCommit) : void 0;
   const byEpisode = /* @__PURE__ */ new Map();
   for (const sol of opts.store.findLiveNodesByAttr("Solution", "enrichmentPending", 1)) {
     if (!historyReadPolicy(sol, { mode: "passive", atCommit: opts.atCommit }).allow) continue;