@inerrata-corporation/errata 2.0.22-dev.4652 → 2.0.22-dev.4657

package/consolidate-worker.mjs

@@ -17126,6 +17126,7 @@ var EXPOSURE_SCOPE = "exposure";
 // ../../packages/local-graph/src/change-feed.ts
 var CHANGE_FEED_KEY = "change-feed";
 var ANY_CHANGE = "*";
+var nodeScope = (label) => `node:${label}`;
 var CHANGE_LOG_KEEP = 25e4;
 var PRUNED_TO_KEY = "change-log-pruned-to";
 function installChangeFeed(db) {
@@ -18040,6 +18041,7 @@ var SqliteGraphStore = class {
   initialPageRankScale;
   constructor(opts) {
     this.db = openDatabase(opts.path);
+    this.db.exec("PRAGMA cache_size = -32768");
     this.db.exec(SCHEMA_SQL);
     const versionRow = this.db.prepare("SELECT version FROM schema_version LIMIT 1").get();
     if (!versionRow) {
@@ -18104,6 +18106,7 @@ var SqliteGraphStore = class {
           attrs_json = excluded.attrs_json
       `),
       getNode: this.db.prepare("SELECT * FROM nodes WHERE id = ?"),
+      labelOf: this.db.prepare("SELECT label FROM nodes WHERE 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).
@@ -18603,11 +18606,13 @@ var SqliteGraphStore = class {
     }
   }
   edgeRuleViolation(edge) {
-    return localEdgeViolation(
-      this.getNode(edge.from)?.label,
-      edge.type,
-      this.getNode(edge.to)?.label
-    );
+    return localEdgeViolation(this.labelOf(edge.from), edge.type, this.labelOf(edge.to));
+  }
+  /** An endpoint's label, any version, as `getNode(id)?.label` reads it. Every
+   *  edge write checks both endpoints, and hydrating them (attrs + vector) to
+   *  read one leading column was most of an incremental reindex's reads. */
+  labelOf(id) {
+    return this.stmts.labelOf.get(id)?.label;
   }
   updateEdge(id, patch) {
     this.stmts.updateEdge.run({
@@ -18651,7 +18656,21 @@ var SqliteGraphStore = class {
    *  per project per request; the materializing form held the daemon's event
    *  loop for seconds at scale. */
   countNodesByLabel(label) {
-    return Number(this.stmts.countByLabel.get(label).n);
+    return this.countAt(`label:${label}`, [nodeScope(label)], () => Number(this.stmts.countByLabel.get(label).n));
+  }
+  /** Counts asked for on every status poll (/health, `errata status`, the
+   *  dashboards): a live-node COUNT(*) reads the whole liveness index, ~3 MB per
+   *  call on a 1.1 GB store, to recount a set that moves only on a write. Each is
+   *  kept with the change-feed reading of the rows it counts — triggers bump it on
+   *  every write from any connection, so a hit is exact, not a TTL guess. */
+  counts = /* @__PURE__ */ new Map();
+  countAt(key, scopes, count) {
+    const seq = readChangeSeq(this.db, scopes);
+    const hit = this.counts.get(key);
+    if (hit && hit.seq === seq) return hit.n;
+    const n = count();
+    this.counts.set(key, { seq, n });
+    return n;
   }
   /** Live rows for a label with attrs and creation stamps only — for scans that
    *  read attrs and never the vector. `findNodesByLabel` decodes every embedding
@@ -18918,7 +18937,7 @@ var SqliteGraphStore = class {
     return out;
   }
   nodeCount() {
-    return Number(this.stmts.nodeCount.get().n);
+    return this.countAt("nodes", [ANY_CHANGE], () => Number(this.stmts.nodeCount.get().n));
   }
   mutationCount() {
     return this.mutations;
@@ -18962,7 +18981,7 @@ var SqliteGraphStore = class {
     return this.ingestSeq;
   }
   edgeCount() {
-    return Number(this.stmts.edgeCount.get().n);
+    return this.countAt("edges", [ANY_CHANGE], () => Number(this.stmts.edgeCount.get().n));
   }
   // Lightweight whole-graph scans — select only the columns the caller needs so a
   // 100k-node pass skips the per-row attrs JSON.parse + embedding decode rowToNode

package/errata.mjs

@@ -20892,6 +20892,7 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
       initialPageRankScale;
       constructor(opts) {
         this.db = openDatabase(opts.path);
+        this.db.exec("PRAGMA cache_size = -32768");
         this.db.exec(SCHEMA_SQL);
         const versionRow = this.db.prepare("SELECT version FROM schema_version LIMIT 1").get();
         if (!versionRow) {
@@ -20956,6 +20957,7 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
           attrs_json = excluded.attrs_json
       `),
           getNode: this.db.prepare("SELECT * FROM nodes WHERE id = ?"),
+          labelOf: this.db.prepare("SELECT label FROM nodes WHERE 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).
@@ -21455,11 +21457,13 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
         }
       }
       edgeRuleViolation(edge2) {
-        return localEdgeViolation(
-          this.getNode(edge2.from)?.label,
-          edge2.type,
-          this.getNode(edge2.to)?.label
-        );
+        return localEdgeViolation(this.labelOf(edge2.from), edge2.type, this.labelOf(edge2.to));
+      }
+      /** An endpoint's label, any version, as `getNode(id)?.label` reads it. Every
+       *  edge write checks both endpoints, and hydrating them (attrs + vector) to
+       *  read one leading column was most of an incremental reindex's reads. */
+      labelOf(id) {
+        return this.stmts.labelOf.get(id)?.label;
       }
       updateEdge(id, patch) {
         this.stmts.updateEdge.run({
@@ -21503,7 +21507,21 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
        *  per project per request; the materializing form held the daemon's event
        *  loop for seconds at scale. */
       countNodesByLabel(label) {
-        return Number(this.stmts.countByLabel.get(label).n);
+        return this.countAt(`label:${label}`, [nodeScope(label)], () => Number(this.stmts.countByLabel.get(label).n));
+      }
+      /** Counts asked for on every status poll (/health, `errata status`, the
+       *  dashboards): a live-node COUNT(*) reads the whole liveness index, ~3 MB per
+       *  call on a 1.1 GB store, to recount a set that moves only on a write. Each is
+       *  kept with the change-feed reading of the rows it counts — triggers bump it on
+       *  every write from any connection, so a hit is exact, not a TTL guess. */
+      counts = /* @__PURE__ */ new Map();
+      countAt(key, scopes, count) {
+        const seq = readChangeSeq(this.db, scopes);
+        const hit = this.counts.get(key);
+        if (hit && hit.seq === seq) return hit.n;
+        const n = count();
+        this.counts.set(key, { seq, n });
+        return n;
       }
       /** Live rows for a label with attrs and creation stamps only — for scans that
        *  read attrs and never the vector. `findNodesByLabel` decodes every embedding
@@ -21770,7 +21788,7 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
         return out2;
       }
       nodeCount() {
-        return Number(this.stmts.nodeCount.get().n);
+        return this.countAt("nodes", [ANY_CHANGE], () => Number(this.stmts.nodeCount.get().n));
       }
       mutationCount() {
         return this.mutations;
@@ -21814,7 +21832,7 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
         return this.ingestSeq;
       }
       edgeCount() {
-        return Number(this.stmts.edgeCount.get().n);
+        return this.countAt("edges", [ANY_CHANGE], () => Number(this.stmts.edgeCount.get().n));
       }
       // Lightweight whole-graph scans — select only the columns the caller needs so a
       // 100k-node pass skips the per-row attrs JSON.parse + embedding decode rowToNode
@@ -39603,9 +39621,10 @@ async function runIndexer(store, opts) {
       if (ei > 0) await new Promise((r) => setImmediate(r));
       const slice = pendingEdges.slice(ei, ei + EDGE_BATCH);
       store.transaction(() => {
+        const present = store.nodeLabels([...new Set(slice.flatMap((e) => [e.from, e.to]))]);
         for (const e of slice) {
           if (e.from === e.to) continue;
-          if (!store.getNode(e.from) || !store.getNode(e.to)) continue;
+          if (!present.has(e.from) || !present.has(e.to)) continue;
           upsertEdge(
             store,
             e.from,
@@ -87006,7 +87025,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.22-dev.4652" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.22-dev.4657" : "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;

package/generalize-worker.mjs

@@ -15700,6 +15700,7 @@ var EXPOSURE_SCOPE = "exposure";
 // ../../packages/local-graph/src/change-feed.ts
 var CHANGE_FEED_KEY = "change-feed";
 var ANY_CHANGE = "*";
+var nodeScope = (label) => `node:${label}`;
 var CHANGE_LOG_KEEP = 25e4;
 var PRUNED_TO_KEY = "change-log-pruned-to";
 function installChangeFeed(db) {
@@ -16437,6 +16438,7 @@ var SqliteGraphStore = class {
   initialPageRankScale;
   constructor(opts) {
     this.db = openDatabase(opts.path);
+    this.db.exec("PRAGMA cache_size = -32768");
     this.db.exec(SCHEMA_SQL);
     const versionRow = this.db.prepare("SELECT version FROM schema_version LIMIT 1").get();
     if (!versionRow) {
@@ -16501,6 +16503,7 @@ var SqliteGraphStore = class {
           attrs_json = excluded.attrs_json
       `),
       getNode: this.db.prepare("SELECT * FROM nodes WHERE id = ?"),
+      labelOf: this.db.prepare("SELECT label FROM nodes WHERE 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).
@@ -17000,11 +17003,13 @@ var SqliteGraphStore = class {
     }
   }
   edgeRuleViolation(edge) {
-    return localEdgeViolation(
-      this.getNode(edge.from)?.label,
-      edge.type,
-      this.getNode(edge.to)?.label
-    );
+    return localEdgeViolation(this.labelOf(edge.from), edge.type, this.labelOf(edge.to));
+  }
+  /** An endpoint's label, any version, as `getNode(id)?.label` reads it. Every
+   *  edge write checks both endpoints, and hydrating them (attrs + vector) to
+   *  read one leading column was most of an incremental reindex's reads. */
+  labelOf(id) {
+    return this.stmts.labelOf.get(id)?.label;
   }
   updateEdge(id, patch) {
     this.stmts.updateEdge.run({
@@ -17048,7 +17053,21 @@ var SqliteGraphStore = class {
    *  per project per request; the materializing form held the daemon's event
    *  loop for seconds at scale. */
   countNodesByLabel(label) {
-    return Number(this.stmts.countByLabel.get(label).n);
+    return this.countAt(`label:${label}`, [nodeScope(label)], () => Number(this.stmts.countByLabel.get(label).n));
+  }
+  /** Counts asked for on every status poll (/health, `errata status`, the
+   *  dashboards): a live-node COUNT(*) reads the whole liveness index, ~3 MB per
+   *  call on a 1.1 GB store, to recount a set that moves only on a write. Each is
+   *  kept with the change-feed reading of the rows it counts — triggers bump it on
+   *  every write from any connection, so a hit is exact, not a TTL guess. */
+  counts = /* @__PURE__ */ new Map();
+  countAt(key, scopes, count) {
+    const seq = readChangeSeq(this.db, scopes);
+    const hit = this.counts.get(key);
+    if (hit && hit.seq === seq) return hit.n;
+    const n = count();
+    this.counts.set(key, { seq, n });
+    return n;
   }
   /** Live rows for a label with attrs and creation stamps only — for scans that
    *  read attrs and never the vector. `findNodesByLabel` decodes every embedding
@@ -17315,7 +17334,7 @@ var SqliteGraphStore = class {
     return out;
   }
   nodeCount() {
-    return Number(this.stmts.nodeCount.get().n);
+    return this.countAt("nodes", [ANY_CHANGE], () => Number(this.stmts.nodeCount.get().n));
   }
   mutationCount() {
     return this.mutations;
@@ -17359,7 +17378,7 @@ var SqliteGraphStore = class {
     return this.ingestSeq;
   }
   edgeCount() {
-    return Number(this.stmts.edgeCount.get().n);
+    return this.countAt("edges", [ANY_CHANGE], () => Number(this.stmts.edgeCount.get().n));
   }
   // Lightweight whole-graph scans — select only the columns the caller needs so a
   // 100k-node pass skips the per-row attrs JSON.parse + embedding decode rowToNode

package/package.json

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

package/pass-worker.mjs

@@ -18280,9 +18280,10 @@ async function runIndexer(store2, opts) {
       if (ei > 0) await new Promise((r) => setImmediate(r));
       const slice = pendingEdges.slice(ei, ei + EDGE_BATCH);
       store2.transaction(() => {
+        const present = store2.nodeLabels([...new Set(slice.flatMap((e) => [e.from, e.to]))]);
         for (const e of slice) {
           if (e.from === e.to) continue;
-          if (!store2.getNode(e.from) || !store2.getNode(e.to)) continue;
+          if (!present.has(e.from) || !present.has(e.to)) continue;
           upsertEdge(
             store2,
             e.from,
@@ -26142,6 +26143,7 @@ var EXPOSURE_SCOPE = "exposure";
 // ../../packages/local-graph/src/change-feed.ts
 var CHANGE_FEED_KEY = "change-feed";
 var ANY_CHANGE = "*";
+var nodeScope = (label) => `node:${label}`;
 var CHANGE_LOG_KEEP = 25e4;
 var PRUNED_TO_KEY = "change-log-pruned-to";
 function installChangeFeed(db) {
@@ -27315,6 +27317,7 @@ var SqliteGraphStore = class {
   initialPageRankScale;
   constructor(opts) {
     this.db = openDatabase(opts.path);
+    this.db.exec("PRAGMA cache_size = -32768");
     this.db.exec(SCHEMA_SQL);
     const versionRow = this.db.prepare("SELECT version FROM schema_version LIMIT 1").get();
     if (!versionRow) {
@@ -27379,6 +27382,7 @@ var SqliteGraphStore = class {
           attrs_json = excluded.attrs_json
       `),
       getNode: this.db.prepare("SELECT * FROM nodes WHERE id = ?"),
+      labelOf: this.db.prepare("SELECT label FROM nodes WHERE 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).
@@ -27878,11 +27882,13 @@ var SqliteGraphStore = class {
     }
   }
   edgeRuleViolation(edge) {
-    return localEdgeViolation(
-      this.getNode(edge.from)?.label,
-      edge.type,
-      this.getNode(edge.to)?.label
-    );
+    return localEdgeViolation(this.labelOf(edge.from), edge.type, this.labelOf(edge.to));
+  }
+  /** An endpoint's label, any version, as `getNode(id)?.label` reads it. Every
+   *  edge write checks both endpoints, and hydrating them (attrs + vector) to
+   *  read one leading column was most of an incremental reindex's reads. */
+  labelOf(id) {
+    return this.stmts.labelOf.get(id)?.label;
   }
   updateEdge(id, patch) {
     this.stmts.updateEdge.run({
@@ -27926,7 +27932,21 @@ var SqliteGraphStore = class {
    *  per project per request; the materializing form held the daemon's event
    *  loop for seconds at scale. */
   countNodesByLabel(label) {
-    return Number(this.stmts.countByLabel.get(label).n);
+    return this.countAt(`label:${label}`, [nodeScope(label)], () => Number(this.stmts.countByLabel.get(label).n));
+  }
+  /** Counts asked for on every status poll (/health, `errata status`, the
+   *  dashboards): a live-node COUNT(*) reads the whole liveness index, ~3 MB per
+   *  call on a 1.1 GB store, to recount a set that moves only on a write. Each is
+   *  kept with the change-feed reading of the rows it counts — triggers bump it on
+   *  every write from any connection, so a hit is exact, not a TTL guess. */
+  counts = /* @__PURE__ */ new Map();
+  countAt(key, scopes, count) {
+    const seq = readChangeSeq(this.db, scopes);
+    const hit = this.counts.get(key);
+    if (hit && hit.seq === seq) return hit.n;
+    const n = count();
+    this.counts.set(key, { seq, n });
+    return n;
   }
   /** Live rows for a label with attrs and creation stamps only — for scans that
    *  read attrs and never the vector. `findNodesByLabel` decodes every embedding
@@ -28193,7 +28213,7 @@ var SqliteGraphStore = class {
     return out2;
   }
   nodeCount() {
-    return Number(this.stmts.nodeCount.get().n);
+    return this.countAt("nodes", [ANY_CHANGE], () => Number(this.stmts.nodeCount.get().n));
   }
   mutationCount() {
     return this.mutations;
@@ -28237,7 +28257,7 @@ var SqliteGraphStore = class {
     return this.ingestSeq;
   }
   edgeCount() {
-    return Number(this.stmts.edgeCount.get().n);
+    return this.countAt("edges", [ANY_CHANGE], () => Number(this.stmts.edgeCount.get().n));
   }
   // Lightweight whole-graph scans — select only the columns the caller needs so a
   // 100k-node pass skips the per-row attrs JSON.parse + embedding decode rowToNode

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

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