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

package/errata.mjs

@@ -18851,6 +18851,122 @@ var init_src2 = __esm({
   }
 });
 
+// ../../packages/local-graph/src/wm-calibration.ts
+function wmCalibrationCells(store) {
+  const cells = {
+    calibrationSchema: WM_CALIBRATION_SCHEMA,
+    shownNodes: 0,
+    shownImpressions: 0,
+    evictedNodes: 0,
+    evictedImpressions: 0,
+    reinforceShown: 0,
+    reinforceRecent: 0,
+    reinforceEvicted: 0,
+    reinforceUnshown: 0,
+    reinforceUnshownQueryOnly: 0,
+    reinforcedNodes: 0,
+    reinforcedShownNodes: 0
+  };
+  const newest = /* @__PURE__ */ new Map();
+  const rows = store.wmCalibrationRows?.(WM_CALIBRATION_LABELS) ?? (function* () {
+    for (const label of WM_CALIBRATION_LABELS) {
+      yield* store.selectNodes({ labels: [label], attrs: WM_CALIBRATION_KEYS, includeClosed: true });
+    }
+  })();
+  for (const n of rows) {
+    const live3 = n.validTo === null;
+    const prev = newest.get(n.logicalId);
+    if (prev && (prev.live || !live3 && prev.version >= n.version)) continue;
+    newest.set(n.logicalId, { version: n.version, live: live3, attrs: n.attrs });
+  }
+  for (const { attrs } of newest.values()) {
+    const shown = num(attrs["shownCount"]);
+    const evicted = num(attrs["evictedCount"]);
+    if (shown > 0) {
+      cells.shownNodes++;
+      cells.shownImpressions += shown;
+    }
+    if (evicted > 0) {
+      cells.evictedNodes++;
+      cells.evictedImpressions += evicted;
+    }
+    const rs = num(attrs["reinforceShownCount"]);
+    const rr = num(attrs["reinforceRecentCount"]);
+    const re = num(attrs["reinforceEvictedCount"]);
+    const ru = num(attrs["reinforceUnshownCount"]);
+    cells.reinforceShown += rs;
+    cells.reinforceRecent += rr;
+    cells.reinforceEvicted += re;
+    cells.reinforceUnshown += ru;
+    cells.reinforceUnshownQueryOnly += num(attrs["reinforceUnshownQueryOnlyCount"]);
+    if (rs + rr + re + ru > 0) cells.reinforcedNodes++;
+    if (rs > 0) cells.reinforcedShownNodes++;
+  }
+  return cells;
+}
+var WM_CALIBRATION_LABELS, WM_CALIBRATION_SCHEMA, num, WM_CALIBRATION_KEYS, WM_COUNTED_PREDICATE, wmCounterSql;
+var init_wm_calibration = __esm({
+  "../../packages/local-graph/src/wm-calibration.ts"() {
+    "use strict";
+    WM_CALIBRATION_LABELS = [
+      "Problem",
+      "Solution",
+      "RootCause",
+      "Pattern",
+      "Technique",
+      "AntiPattern"
+    ];
+    WM_CALIBRATION_SCHEMA = 2;
+    num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+    WM_CALIBRATION_KEYS = [
+      "shownCount",
+      "evictedCount",
+      "reinforceShownCount",
+      "reinforceRecentCount",
+      "reinforceEvictedCount",
+      "reinforceUnshownCount",
+      "reinforceUnshownQueryOnlyCount"
+    ];
+    WM_COUNTED_PREDICATE = WM_CALIBRATION_KEYS.map((k) => `json_type(attrs_json, '$.${k}') IS NOT NULL`).join(" OR ");
+    wmCounterSql = (k) => `CASE WHEN json_type(attrs_json, '$.${k}') IN ('integer', 'real') THEN json_extract(attrs_json, '$.${k}') END`;
+  }
+});
+
+// ../../packages/local-graph/src/exposure-attrs.ts
+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)`;
+}
+var EXPOSURE_ATTRS, EXPOSURE_SCOPE, EXPOSURE_KEYS, isExposureAttr;
+var init_exposure_attrs = __esm({
+  "../../packages/local-graph/src/exposure-attrs.ts"() {
+    "use strict";
+    EXPOSURE_ATTRS = [
+      "shownCount",
+      "evictedCount",
+      "firstShownAt",
+      "firstEvictedAt",
+      "firstShownAtSeq",
+      "lastShownAtSeq",
+      "lastEvictedAtSeq",
+      "shownSinceTouch",
+      "shownSinceTouchAt",
+      "exposureLog",
+      "exposureLogStart",
+      "exposureLogSince",
+      "exposureFirst",
+      "exposureTrimmed"
+    ];
+    EXPOSURE_SCOPE = "exposure";
+    EXPOSURE_KEYS = new Set(EXPOSURE_ATTRS);
+    isExposureAttr = (key) => EXPOSURE_KEYS.has(key);
+  }
+});
+
 // ../../packages/local-graph/src/history-cache-floor.ts
 function installHistoryCacheFloor(db) {
   const key = HISTORY_CACHE_FLOOR_KEY;
@@ -19171,31 +19287,6 @@ var init_text_index = __esm({
   }
 });
 
-// ../../packages/local-graph/src/exposure-attrs.ts
-var EXPOSURE_ATTRS, EXPOSURE_SCOPE;
-var init_exposure_attrs = __esm({
-  "../../packages/local-graph/src/exposure-attrs.ts"() {
-    "use strict";
-    EXPOSURE_ATTRS = [
-      "shownCount",
-      "evictedCount",
-      "firstShownAt",
-      "firstEvictedAt",
-      "firstShownAtSeq",
-      "lastShownAtSeq",
-      "lastEvictedAtSeq",
-      "shownSinceTouch",
-      "shownSinceTouchAt",
-      "exposureLog",
-      "exposureLogStart",
-      "exposureLogSince",
-      "exposureFirst",
-      "exposureTrimmed"
-    ];
-    EXPOSURE_SCOPE = "exposure";
-  }
-});
-
 // ../../packages/local-graph/src/change-feed.ts
 function installChangeFeed(db) {
   if (changeFeedInstalled(db)) return;
@@ -19254,6 +19345,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 });
@@ -20455,8 +20556,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)}`;
@@ -20469,7 +20573,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`;
@@ -20535,6 +20639,7 @@ var SELECT_INDEXES, EMBEDDING_DIM_SQL, KEY, COLUMNS;
 var init_node_select = __esm({
   "../../packages/local-graph/src/node-select.ts"() {
     "use strict";
+    init_exposure_attrs();
     SELECT_INDEXES = [
       "nodes_live_local_community",
       "nodes_live_fold_candidate",
@@ -20587,7 +20692,7 @@ function graphStoreNeedsPreparation(path3) {
       if (!indexes.has(match2[1])) return true;
     }
     if (!changeFeedInstalled(db)) return true;
-    return [SESSION_REPAIR_KEY, HISTORY_CACHE_FLOOR_KEY, EDIT_PLACEHOLDER_FLOOR_KEY, CLOUD_ATTR_COMPACTION_KEY, HISTORY_ATTR_SLIM_KEY, TEXT_INDEX_KEY, LINEAGE_INTEGRITY_KEY].some((key) => !db.prepare("SELECT value FROM store_meta WHERE key = ?").get(key));
+    return [SESSION_REPAIR_KEY, HISTORY_CACHE_FLOOR_KEY, EDIT_PLACEHOLDER_FLOOR_KEY, CLOUD_ATTR_COMPACTION_KEY, HISTORY_ATTR_SLIM_KEY, TEXT_INDEX_KEY, LINEAGE_INTEGRITY_KEY, EXPOSURE_SIDE_KEY].some((key) => !db.prepare("SELECT value FROM store_meta WHERE key = ?").get(key));
   } catch {
     return true;
   } finally {
@@ -20654,12 +20759,14 @@ function rowToEdge(r) {
 function openGraphStore(opts) {
   return new SqliteGraphStore(opts);
 }
-var PAGE_RANK_SCALE_KEY, TEXT_SEARCH_COLUMNS, LOCAL_RULE_OVERRIDES, SCHEMA_VERSION, SESSION_REPAIR_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, PRIOR_TAG_MARKER, SqliteGraphStore;
 var init_store = __esm({
   "../../packages/local-graph/src/store.ts"() {
     "use strict";
     init_src2();
     init_src();
+    init_wm_calibration();
+    init_exposure_attrs();
     init_history_cache_floor();
     init_session_evidence();
     init_edit_placeholder_retirement();
@@ -20704,6 +20811,7 @@ var init_store = __esm({
     };
     SCHEMA_VERSION = 6;
     SESSION_REPAIR_KEY = "session-evidence-v1";
+    EXPOSURE_SIDE_KEY = "exposure-side-rows-1";
     SESSION_EVIDENCE_PREDICATE = SESSION_EVIDENCE_FIELDS.map((field) => `instr(attrs_json, '${JSON.stringify(field)}') > 0`).join(" OR ");
     SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS schema_version (
@@ -20767,8 +20875,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,
@@ -20790,7 +20903,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);
@@ -20812,6 +20928,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).
@@ -20819,6 +20941,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
@@ -20915,6 +21040,7 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
       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) {
@@ -20978,8 +21104,17 @@ 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
       `),
-          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).
@@ -21136,6 +21271,7 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
             "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;
       }
@@ -21191,6 +21327,41 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
         ORDER BY label, created_at, rowid`
         ).all(label);
       }
+      wmCalibrationRows(labels) {
+        const counted = this.db.prepare(
+          `SELECT rowid AS rid, logical_id, version, valid_to, label, ${WM_CALIBRATION_KEYS.map((k, i2) => `${wmCounterSql(k)} AS c${i2}`).join(", ")}
+         FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE}`
+        ).all();
+        const 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
@@ -21327,9 +21498,22 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
           logical_id: node2.logicalId ?? node2.id,
           created_at_seq: node2.createdAtSeq ?? null,
           last_reinforced_at_seq: node2.lastReinforcedAtSeq ?? null,
-          attrs_json: JSON.stringify(node2.attrs ?? {})
+          attrs_json: this.nodeAttrsJson(node2.id, node2.attrs ?? {})
         });
       }
+      /** mergeNode, unless the live row already holds this content. Content is what
+       *  the columns a merge rewrites from the producer (label, description, attrs,
+       *  confidence, stability);
+       *  rank, community, landmark, surprise, hits, tier and the vector belong to
+       *  the passes that compute them, and a skipped write leaves them as they are
+       *  where a merge would have reset them to the producer's defaults. Returns
+       *  whether it wrote. */
+      mergeNodeIfChanged(node2) {
+        const row = this.stmts.nodeContent.get(node2.id);
+        if (row && row.valid_to === null && row.label === node2.label && row.description === node2.description && row.extraction_confidence === node2.extractionConfidence && row.stability === node2.stability && !EXPOSURE_ATTRS.some((k) => node2.attrs?.[k] !== void 0) && row.attrs_json === JSON.stringify(node2.attrs ?? {})) return false;
+        this.mergeNode(node2);
+        return true;
+      }
       updateNode(id, patch) {
         const hasEmbedding = patch.embedding !== void 0 && patch.embedding.length > 0;
         this.stmts.updateNode.run({
@@ -21353,7 +21537,37 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
           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 rest2 = { ...attrs };
+        for (const k of EXPOSURE_ATTRS) delete rest2[k];
+        return JSON.stringify(rest2);
+      }
+      /** 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
@@ -21435,6 +21649,21 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
           attrs_json: JSON.stringify(edge2.attrs ?? {})
         });
       }
+      /** mergeEdge, unless the live edge already holds this content: same attrs, and
+       *  a confidence the upsert's MAX would keep. Its navigation posteriors and
+       *  last-seen stamp stay as they are where a merge would have reset them. The
+       *  ontology gate runs first either way, so refusals are recorded as before.
+       *  Returns whether it wrote (or refused). */
+      mergeEdgeIfChanged(edge2) {
+        if (!this.edgeRuleViolation(edge2)) {
+          const row = this.stmts.edgeContent.get(edge2.from, edge2.type, edge2.to);
+          if (row && row.valid_to === null && row.confidence >= edge2.confidence && row.attrs_json === JSON.stringify(edge2.attrs ?? {})) {
+            return false;
+          }
+        }
+        this.mergeEdge(edge2);
+        return true;
+      }
       /** EDGE_RULES check against the stored endpoints' labels, with the LOCAL
        *  overlay consulted first. Returns the reason string on a documented-
        *  forbidden combination, else null. Point lookups on the id PK — negligible
@@ -21501,7 +21730,27 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
       }
       getNode(id) {
         const row = this.stmts.getNode.get(id);
-        return row ? rowToNode(row) : null;
+        if (!row) return null;
+        const node2 = rowToNode(row);
+        if (row.exposure_json) Object.assign(node2.attrs, JSON.parse(row.exposure_json));
+        return node2;
+      }
+      /** 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;
@@ -21552,7 +21801,7 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
       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);
@@ -21569,7 +21818,7 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
         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);
@@ -21829,6 +22078,9 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
       changedNodeIds(sinceSeq, labels) {
         return readChangedNodeIds(this.db, sinceSeq, labels);
       }
+      changedAmong(sinceSeq, ids) {
+        return readChangedAmong(this.db, sinceSeq, ids);
+      }
       pruneChangeLog() {
         return pruneChangeLog(this.db);
       }
@@ -24791,9 +25043,11 @@ function recordRenderLedger(store, ledger, seq, ts) {
   const bump = (ids, field) => {
     let n = 0;
     for (const id of new Set(ids.map((i2) => i2.id))) {
-      const node2 = store.getNode(id);
-      if (!node2) continue;
-      const attrs = { ...node2.attrs };
+      const side = store.exposureOf?.(id);
+      const node2 = side ? null : store.getNode(id);
+      if (!side && !node2) continue;
+      const lastUpdatedAt = side ? side.lastUpdatedAt : node2.lastUpdatedAt;
+      const attrs = side ? { ...side.attrs } : { ...node2.attrs };
       if (field === "shownCount" && attrs["firstShownAt"] === void 0) {
         attrs["firstShownAt"] = attrs["firstShownAtSeq"] !== void 0 || attrs["lastShownAtSeq"] !== void 0 ? 0 : ts;
       }
@@ -24804,15 +25058,16 @@ function recordRenderLedger(store, ledger, seq, ts) {
       if (field === "shownCount") {
         attrs["lastShownAtSeq"] = seq;
         if (attrs["firstShownAtSeq"] === void 0) attrs["firstShownAtSeq"] = seq;
-        const counted = attrs["shownSinceTouchAt"] === node2.lastUpdatedAt ? Number(attrs["shownSinceTouch"] ?? 0) : 0;
+        const counted = attrs["shownSinceTouchAt"] === lastUpdatedAt ? Number(attrs["shownSinceTouch"] ?? 0) : 0;
         attrs["shownSinceTouch"] = counted + 1;
-        attrs["shownSinceTouchAt"] = node2.lastUpdatedAt;
+        attrs["shownSinceTouchAt"] = lastUpdatedAt;
         logImpression(attrs, ts, retrieved.has(id) ? "r" : "c");
       } else {
         attrs["lastEvictedAtSeq"] = seq;
         logImpression(attrs, ts, "e");
       }
-      store.updateNode(id, { attrs, lastUpdatedAt: node2.lastUpdatedAt });
+      if (side) store.writeExposure(id, pickExposure(attrs));
+      else store.updateNode(id, { attrs, lastUpdatedAt });
       n++;
     }
     return n;
@@ -24921,6 +25176,7 @@ var init_design_problem = __esm({
     init_src();
     init_src();
     init_problem_package_link();
+    init_exposure_attrs();
     init_src4();
     init_src2();
     init_problem_package_link();
@@ -27438,82 +27694,6 @@ var init_mechanism_liveness = __esm({
   }
 });
 
-// ../../packages/local-graph/src/wm-calibration.ts
-function wmCalibrationCells(store) {
-  const cells = {
-    calibrationSchema: WM_CALIBRATION_SCHEMA,
-    shownNodes: 0,
-    shownImpressions: 0,
-    evictedNodes: 0,
-    evictedImpressions: 0,
-    reinforceShown: 0,
-    reinforceRecent: 0,
-    reinforceEvicted: 0,
-    reinforceUnshown: 0,
-    reinforceUnshownQueryOnly: 0,
-    reinforcedNodes: 0,
-    reinforcedShownNodes: 0
-  };
-  const newest = /* @__PURE__ */ new Map();
-  for (const label of WM_CALIBRATION_LABELS) {
-    for (const n of store.selectNodes({ labels: [label], attrs: WM_CALIBRATION_KEYS, includeClosed: true })) {
-      const live3 = n.validTo === null;
-      const prev = newest.get(n.logicalId);
-      if (prev && (prev.live || !live3 && prev.version >= n.version)) continue;
-      newest.set(n.logicalId, { version: n.version, live: live3, attrs: n.attrs });
-    }
-  }
-  for (const { attrs } of newest.values()) {
-    const shown = num(attrs["shownCount"]);
-    const evicted = num(attrs["evictedCount"]);
-    if (shown > 0) {
-      cells.shownNodes++;
-      cells.shownImpressions += shown;
-    }
-    if (evicted > 0) {
-      cells.evictedNodes++;
-      cells.evictedImpressions += evicted;
-    }
-    const rs = num(attrs["reinforceShownCount"]);
-    const rr = num(attrs["reinforceRecentCount"]);
-    const re = num(attrs["reinforceEvictedCount"]);
-    const ru = num(attrs["reinforceUnshownCount"]);
-    cells.reinforceShown += rs;
-    cells.reinforceRecent += rr;
-    cells.reinforceEvicted += re;
-    cells.reinforceUnshown += ru;
-    cells.reinforceUnshownQueryOnly += num(attrs["reinforceUnshownQueryOnlyCount"]);
-    if (rs + rr + re + ru > 0) cells.reinforcedNodes++;
-    if (rs > 0) cells.reinforcedShownNodes++;
-  }
-  return cells;
-}
-var WM_CALIBRATION_LABELS, WM_CALIBRATION_SCHEMA, num, WM_CALIBRATION_KEYS;
-var init_wm_calibration = __esm({
-  "../../packages/local-graph/src/wm-calibration.ts"() {
-    "use strict";
-    WM_CALIBRATION_LABELS = [
-      "Problem",
-      "Solution",
-      "RootCause",
-      "Pattern",
-      "Technique",
-      "AntiPattern"
-    ];
-    WM_CALIBRATION_SCHEMA = 2;
-    num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
-    WM_CALIBRATION_KEYS = [
-      "shownCount",
-      "evictedCount",
-      "reinforceShownCount",
-      "reinforceRecentCount",
-      "reinforceEvictedCount",
-      "reinforceUnshownCount",
-      "reinforceUnshownQueryOnlyCount"
-    ];
-  }
-});
-
 // ../../packages/local-graph/src/index.ts
 var src_exports2 = {};
 __export(src_exports2, {
@@ -27560,8 +27740,10 @@ __export(src_exports2, {
   STALL_MIN_RUNS: () => STALL_MIN_RUNS,
   STALL_MIN_SPAN_MS: () => STALL_MIN_SPAN_MS,
   SqliteGraphStore: () => SqliteGraphStore,
+  WM_CALIBRATION_KEYS: () => WM_CALIBRATION_KEYS,
   WM_CALIBRATION_LABELS: () => WM_CALIBRATION_LABELS,
   WM_CALIBRATION_SCHEMA: () => WM_CALIBRATION_SCHEMA,
+  WM_COUNTED_PREDICATE: () => WM_COUNTED_PREDICATE,
   WORKSPACE_SCAN_CAP: () => WORKSPACE_SCAN_CAP,
   addDependency: () => addDependency,
   aggregateClaimConfidence: () => aggregateClaimConfidence,
@@ -27708,7 +27890,8 @@ __export(src_exports2, {
   upgradeAnchorHints: () => upgradeAnchorHints,
   upgradeAnchorHintsForFile: () => upgradeAnchorHintsForFile,
   walk: () => walk,
-  wmCalibrationCells: () => wmCalibrationCells
+  wmCalibrationCells: () => wmCalibrationCells,
+  wmCounterSql: () => wmCounterSql
 });
 var init_src5 = __esm({
   "../../packages/local-graph/src/index.ts"() {
@@ -27741,6 +27924,95 @@ var init_src5 = __esm({
   }
 });
 
+// ../../packages/context-writer/src/snapshot-inputs.ts
+function guardSnapshotReads(store) {
+  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(store.getNode(id), "getNode"),
+    selectNodes: (q) => {
+      for (const l of q.labels) label(l, "selectNodes");
+      return store.selectNodes(q);
+    },
+    countNodes: (q) => {
+      for (const l of q.labels) label(l, "countNodes");
+      return store.countNodes(q);
+    },
+    findLiveNodesByAttr: (l, ...rest2) => {
+      label(l, "findLiveNodesByAttr");
+      return store.findLiveNodesByAttr(l, ...rest2);
+    },
+    outEdges: (id, t) => {
+      types(t, "outEdges");
+      return store.outEdges(id, t);
+    },
+    inEdges: (id, t) => {
+      types(t, "inEdges");
+      return store.inEdges(id, t);
+    },
+    inDegreeByType: (t) => {
+      types(t, "inDegreeByType");
+      return store.inDegreeByType(t);
+    },
+    nodesAsOfWhereTrue: (asOf, attr) => {
+      if (attr !== "revisit") fail(`nodesAsOfWhereTrue(${String(attr)})`);
+      return store.nodesAsOfWhereTrue(asOf, attr);
+    }
+  };
+  return new Proxy(store, {
+    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;
+    }
+  });
+}
+var SNAPSHOT_NODE_LABELS, SNAPSHOT_EDGE_TYPES, SNAPSHOT_READ_GUARD, LABELS, EDGES;
+var init_snapshot_inputs = __esm({
+  "../../packages/context-writer/src/snapshot-inputs.ts"() {
+    "use strict";
+    SNAPSHOT_NODE_LABELS = [
+      "Problem",
+      "Vulnerability",
+      "Solution",
+      "Pattern",
+      "Technique",
+      "AntiPattern",
+      "Language",
+      "Package",
+      "Tool"
+    ];
+    SNAPSHOT_EDGE_TYPES = [
+      "ANCHORED_AT",
+      "CAUSED_BY",
+      "CONCERNS",
+      "DEPENDS_ON",
+      "EVIDENCED_BY",
+      "MANIFESTED_IN",
+      "OCCURS_IN",
+      "PERTAIN_TO",
+      "REGRESSION_OF",
+      "SOLVED_BY"
+    ];
+    SNAPSHOT_READ_GUARD = typeof process !== "undefined" && Boolean(process.env["VITEST"]);
+    LABELS = new Set(SNAPSHOT_NODE_LABELS);
+    EDGES = new Set(SNAPSHOT_EDGE_TYPES);
+  }
+});
+
 // ../../packages/context-writer/src/render.ts
 function isPassiveInjectable(node2, atCommit) {
   if (!historyReadPolicy(node2, { mode: "passive", atCommit }).allow) return false;
@@ -27766,6 +28038,8 @@ function passiveAllowed(row, atCommit) {
   return historyReadPolicy({ extractionSource: row.extractionSource, attrs: row.attrs }, { mode: "passive", atCommit }).allow;
 }
 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);
@@ -27801,7 +28075,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;
@@ -28482,6 +28756,7 @@ var init_render = __esm({
     init_src5();
     init_src2();
     init_src();
+    init_snapshot_inputs();
     MOTIF_BAND = 10;
     MOTIF_POOL = 1e3;
     MOTIF_SEEDS = 8;
@@ -28811,6 +29086,7 @@ var init_src6 = __esm({
     init_context_file();
     init_redirectors();
     init_render();
+    init_snapshot_inputs();
     init_bleed_memory();
     init_bleed_rules();
     init_select_durable_memory();
@@ -38815,10 +39091,20 @@ function isReExportBarrel(relPath) {
 function graphExportMap(store, workspaceId2, relPath) {
   const out2 = /* @__PURE__ */ new Map();
   const fileId = fileNodeId(workspaceId2, relPath);
-  if (!store.getNode(fileId)) return out2;
-  for (const e of store.outEdges(fileId, ["DEFINES"])) {
-    const n = store.getNode(e.to);
-    if (!n || !EXPORTABLE_LABELS.has(n.label)) continue;
+  if (store.nodeLabels([fileId]).size === 0) return out2;
+  const defines = store.outEdges(fileId, ["DEFINES"]);
+  const rows = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < defines.length; i2 += 500) {
+    for (const r of store.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"] !== workspaceId2) continue;
     const name2 = n.attrs["name"] ?? n.description;
     if (!name2 || name2.startsWith("<") || name2.includes(":")) continue;
@@ -38994,7 +39280,28 @@ async function incrementalReindex(store, rootPath, workspaceId2, changedAbsPaths
       store.closeNode(nid, t);
     }
   });
-  const r = await runIndexer(store, {
+  const seenNodes = /* @__PURE__ */ new Set();
+  const seenEdges = /* @__PURE__ */ new Set();
+  const writeStore = store.mergeNodeIfChanged && store.mergeEdgeIfChanged ? new Proxy(store, {
+    get(target, prop) {
+      if (prop === "mergeNode") {
+        return (n) => {
+          seenNodes.add(n.id);
+          if (n.label === "File" || n.label === "Folder") target.mergeNode(n);
+          else target.mergeNodeIfChanged(n);
+        };
+      }
+      if (prop === "mergeEdge") {
+        return (e) => {
+          seenEdges.add(edgeId(e.from, e.type, e.to));
+          target.mergeEdgeIfChanged(e);
+        };
+      }
+      const v = Reflect.get(target, prop, target);
+      return typeof v === "function" ? v.bind(target) : v;
+    }
+  }) : store;
+  const r = await runIndexer(writeStore, {
     workspaceId: workspaceId2,
     rootPath,
     providers,
@@ -39012,14 +39319,14 @@ async function incrementalReindex(store, rootPath, workspaceId2, changedAbsPaths
       if (typeof rel !== "string" || !changedRelPaths.has(rel)) continue;
       if (versionedAndFile.has(n.label)) {
         ownedLive.push(n.id);
-      } else if (n.label === "Comment" && n.lastUpdatedAt < t) {
+      } else if (n.label === "Comment" && n.lastUpdatedAt < t && !seenNodes.has(n.id)) {
         store.closeNode(n.id, t);
       }
     }
     for (const id of ownedLive) {
       for (const e of store.outEdges(id)) {
         if (e.type === "SUPERSEDED_BY") continue;
-        if (e.lastSeenAt < t) {
+        if (e.lastSeenAt < t && !seenEdges.has(edgeId(e.from, e.type, e.to))) {
           store.closeEdge(e.id, t);
           delta.edgesRemoved++;
         } else if (e.createdAt >= t) {
@@ -80386,6 +80693,13 @@ init_session_registry();
 import { readFileSync as readFileSync18, renameSync as renameSync3, statSync as statSync8, writeFileSync as writeFileSync14 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { dirname as dirname11, join as join22 } from "node:path";
+function revisitFlagsUnchanged(store, held, flaggedNow) {
+  if (held.anySeq === void 0 || held.revisitIds === void 0 || !store.changedAmong) return false;
+  const watched = [.../* @__PURE__ */ new Set([...held.revisitIds, ...flaggedNow])];
+  if (watched.length === 0) return true;
+  const changed = store.changedAmong(held.anySeq, watched);
+  return changed !== null && changed.length === 0;
+}
 function snapshotReusable(held, want) {
   return held !== null && held.key === want.key && held.atCommit === want.atCommit;
 }
@@ -83238,12 +83552,40 @@ function withHeavyPassSlot(label, fn) {
   return run3;
 }
 
+// src/warm-worker.ts
+var WARM_HEAP_CEILING_BYTES = 256 * 1024 * 1024;
+var WARM_IDLE_MS = 2 * 60 * 1e3;
+async function mayStayWarm(worker, ceiling = WARM_HEAP_CEILING_BYTES) {
+  const stats = await worker.getHeapStatistics?.().catch(() => void 0);
+  return stats !== void 0 && stats.total_heap_size <= ceiling;
+}
+var IdleRecycle = class {
+  constructor(recycle, idleMs = WARM_IDLE_MS) {
+    this.recycle = recycle;
+    this.idleMs = idleMs;
+  }
+  timer = null;
+  arm() {
+    this.clear();
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.recycle();
+    }, this.idleMs);
+    this.timer.unref?.();
+  }
+  clear() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+};
+
 // src/pass-worker-client.ts
 var PassWorker = class {
   constructor(init2) {
     this.init = init2;
   }
   worker = null;
+  idle = new IdleRecycle(() => void this.recycleIdle());
   ready = null;
   pending = /* @__PURE__ */ new Map();
   nextId = 1;
@@ -83290,6 +83632,7 @@ var PassWorker = class {
     if (this.stopped) return Promise.reject(new Error("pass worker stopped"));
     return withHeavyPassSlot(`${kind}:${this.init.workspaceId}`, async () => {
       if (this.stopped) throw new Error("pass worker stopped");
+      this.idle.clear();
       this.ensureWorker();
       const id = this.nextId++;
       try {
@@ -83299,7 +83642,8 @@ var PassWorker = class {
           this.worker.postMessage({ id, kind, ...payload !== void 0 ? { payload } : {} });
         });
       } finally {
-        await this.recycleIdle();
+        if (this.worker && this.pending.size === 0 && !this.stopped && await mayStayWarm(this.worker)) this.idle.arm();
+        else await this.recycleIdle();
       }
     });
   }
@@ -83363,6 +83707,7 @@ var PassWorker = class {
   }
   async stop() {
     this.stopped = true;
+    this.idle.clear();
     const w = this.worker;
     this.worker = null;
     this.ready = null;
@@ -87049,7 +87394,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.22-dev.4665" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.22-dev.4676" : "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;
@@ -87475,6 +87820,7 @@ function createWorkspaceEngine(opts) {
   let ctxRefreshInFlight = false;
   let ctxRefreshQueued = false;
   let lastWorkerSnapshot = null;
+  const SNAPSHOT_SCOPES = [...SNAPSHOT_NODE_LABELS.map(nodeScope), ...SNAPSHOT_EDGE_TYPES.map(edgeScope)];
   let lastSelfCiteSkips = 0;
   const refreshContextNow = () => {
     void refreshContextAsync().catch((err2) => {
@@ -87560,21 +87906,30 @@ function createWorkspaceEngine(opts) {
       skills: readSkillManifest(paths.skillsManifest),
       ...lastSelfCiteSkips > 0 ? { selfCiteSkips: lastSelfCiteSkips } : {}
     };
-    const changes = store.changeSeq ? store.changeSeq() - store.changeSeq([EXPOSURE_SCOPE]) : store.changeStamp();
+    const changes = store.changeSeq ? store.changeSeq(SNAPSHOT_SCOPES) : store.changeStamp();
+    const anySeq = store.changeSeq?.();
     const { id, name: name2, stack, languages, domains, goals } = snapOpts.profile;
     const { workingFile: _workingFile, ...keyedOpts } = snapOpts;
     const snapshotKey = `${snapshotCodeIdentity(DAEMON_VERSION)}|${changes}|${JSON.stringify({ ...keyedOpts, profile: { id, name: name2, stack, languages, domains, goals } })}`;
     lastWorkerSnapshot ??= loadHeldSnapshot(heldSnapshotPath(paths.configDir));
     const held = lastWorkerSnapshot;
-    const withWorkingFile = (snap, builtFor, want, atCommit) => {
-      if (builtFor === want) return snap;
+    const withWorkingFile = (snap, want, atCommit) => {
       const slice = want ? sliceForFile(store, want, atCommit) : void 0;
       if (slice) snap.workingFile = slice;
       else delete snap.workingFile;
       return snap;
     };
-    const prebuilt = snapshotReusable(held, { key: snapshotKey, atCommit: snapOpts.atCommit }) ? withWorkingFile(structuredClone(held.snapshot), held.workingFile, snapOpts.workingFile, snapOpts.atCommit) : passWorker ? await passWorker.snapshot(snapOpts).then((snapshot2) => {
-      lastWorkerSnapshot = { key: snapshotKey, at: Date.now(), atCommit: snapOpts.atCommit, workingFile: snapOpts.workingFile, snapshot: structuredClone(snapshot2) };
+    const revisitIds = store.nodesAsOfWhereTrue(Date.now(), "revisit").map((n) => n.id);
+    const prebuilt = snapshotReusable(held, { key: snapshotKey, atCommit: snapOpts.atCommit }) && revisitFlagsUnchanged(store, held, revisitIds) ? withWorkingFile(structuredClone(held.snapshot), snapOpts.workingFile, snapOpts.atCommit) : passWorker ? await passWorker.snapshot(snapOpts).then((snapshot2) => {
+      lastWorkerSnapshot = {
+        key: snapshotKey,
+        at: Date.now(),
+        atCommit: snapOpts.atCommit,
+        workingFile: snapOpts.workingFile,
+        ...anySeq !== void 0 ? { anySeq } : {},
+        revisitIds,
+        snapshot: structuredClone(snapshot2)
+      };
       saveHeldSnapshot(heldSnapshotPath(paths.configDir), lastWorkerSnapshot);
       return snapshot2;
     }).catch((err2) => {
@@ -91598,6 +91953,7 @@ init_session_registry();
 import { Worker as Worker2 } from "node:worker_threads";
 var ConsolidateWorker = class {
   worker = null;
+  idle = new IdleRecycle(() => void this.recycleIdle());
   ready = null;
   pending = /* @__PURE__ */ new Map();
   nextId = 1;
@@ -91608,6 +91964,7 @@ var ConsolidateWorker = class {
     if (this.stopped) return Promise.reject(new Error("consolidate worker stopped"));
     return withHeavyPassSlot(`consolidate:${req.kind ?? "pass"}`, async () => {
       if (this.stopped) throw new Error("consolidate worker stopped");
+      this.idle.clear();
       this.ensureWorker();
       const id = this.nextId++;
       try {
@@ -91617,7 +91974,8 @@ var ConsolidateWorker = class {
           this.worker.postMessage({ ...req, id });
         });
       } finally {
-        await this.recycleIdle();
+        if (this.worker && this.pending.size === 0 && !this.stopped && await mayStayWarm(this.worker)) this.idle.arm();
+        else await this.recycleIdle();
       }
     });
   }
@@ -91680,6 +92038,7 @@ var ConsolidateWorker = class {
   }
   async stop() {
     this.stopped = true;
+    this.idle.clear();
     if (this.worker) {
       await this.worker.terminate().catch(() => {
       });
@@ -93526,7 +93885,7 @@ var GitBlobReader = class {
 init_src11();
 init_src();
 import { extname as extname4 } from "node:path";
-var LABELS = {
+var LABELS2 = {
   function: "Function",
   class: "Class",
   method: "Method",
@@ -93560,7 +93919,7 @@ async function historicalAnchors(input) {
         const source = await input.readBlob(spec);
         if (source === null || source.includes("\0") || Buffer.byteLength(source) > MAX_SOURCE_BYTES) return null;
         await provider.preload?.();
-        const symbols = provider.extractSymbols(source, path3).filter((s) => LABELS[s.kind] && s.startByte >= 0 && s.endByte > s.startByte);
+        const symbols = provider.extractSymbols(source, path3).filter((s) => LABELS2[s.kind] && s.startByte >= 0 && s.endByte > s.startByte);
         const offsets = [0];
         for (let i2 = 0; i2 < source.length; i2++) if (source[i2] === "\n") offsets.push(i2 + 1);
         offsets.push(source.length + 1);
@@ -93595,7 +93954,7 @@ async function historicalAnchors(input) {
             const symbols = file2.symbols.filter((s) => s.startByte < stop2 && s.endByte > start2).sort((a, b) => a.endByte - a.startByte - (b.endByte - b.startByte));
             const symbol2 = symbols[0];
             if (symbol2) {
-              const kind = LABELS[symbol2.kind];
+              const kind = LABELS2[symbol2.kind];
               const symbolId = projectSymbolId(input.salt, input.projectId, input.bundle.pathTokens[token], symbol2.qname ?? symbol2.name, kind);
               const prev = list.at(-1);
               if (prev?.symbolId === symbolId && prev.historical?.side === side && prev.historical.blockDigest === block.digest && prev.historical.endByte + 1 === offset) {