@inerrata-corporation/errata 2.0.22-dev.4669 → 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;
@@ -25938,6 +25948,35 @@ function wmCalibrationCells(store2) {
   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) {
@@ -26222,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 = "*";
@@ -26304,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 });
@@ -27037,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)}`;
@@ -27051,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`;
@@ -27168,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 (
@@ -27231,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,
@@ -27254,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);
@@ -27276,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).
@@ -27439,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) {
@@ -27502,7 +27551,10 @@ 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 = ?"
@@ -27666,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;
   }
@@ -27726,21 +27779,35 @@ var SqliteGraphStore = class {
       `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})
-         EXCEPT SELECT rowid FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE})`
+          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 order = new Map(labels.map((l, i2) => [l, i2]));
-    return [...counted, ...others].filter((r) => order.has(r.label)).sort((a, b) => order.get(a.label) - order.get(b.label) || a.rid - b.rid).map((r) => {
+    const 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;
       });
-      return { logicalId: r.logical_id, version: Number(r.version), validTo: r.valid_to ?? null, attrs };
-    });
+      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(
@@ -27878,7 +27945,7 @@ 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
@@ -27890,7 +27957,7 @@ var SqliteGraphStore = class {
    *  whether it wrote. */
   mergeNodeIfChanged(node) {
     const row = this.stmts.nodeContent.get(node.id);
-    if (row && row.valid_to === null && row.label === node.label && row.description === node.description && row.extraction_confidence === node.extractionConfidence && row.stability === node.stability && row.attrs_json === JSON.stringify(node.attrs ?? {})) return false;
+    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;
   }
@@ -27917,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
@@ -28080,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;
@@ -28131,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);
@@ -28148,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);
@@ -28408,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);
   }
@@ -31097,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) {
@@ -31117,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);
@@ -31152,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;

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

@@ -1,6 +1,6 @@
 {
   "name": "errata-context",
-  "version": "2.0.22-dev.4669",
+  "version": "2.0.22-dev.4676",
   "description": "A minimal 3D view of loaded Errata priors and recent graph bursts.",
   "author": {
     "name": "inErrata"

package/resources/context-plugin/SHA256SUMS

@@ -1,4 +1,4 @@
-235e69b11fb75b5854bbe0e3e025fdad29c29d8b5b34159bd8270bfb8b235b0b  .codex-plugin/plugin.json
+aed45b59cddfbffc63052b049122c7b5303eb3f921379af8ac2e969ded158d58  .codex-plugin/plugin.json
 a7bebae9fb01c838d6c75fc784129e28be571233fa66ff5ee8039b574f35ccf7  assets/icon.png
 fc38b64e4df1e0b72c35764bef6c4c05430d97c9009ad0ecc8a9e75b4deab232  configure-local.mjs
 73dc6028b3b070257c7c31f252d11e55a9e096f4aed0f187f10cb21716e1e6d7  dist/client.js