@inerrata-corporation/errata 2.0.6-dev.2618 → 2.0.6-dev.2627

package/consolidate-worker.mjs

@@ -16343,6 +16343,10 @@ var SqliteGraphStore = class {
       countByLabel: this.db.prepare(
         "SELECT COUNT(*) AS n FROM nodes WHERE label = ? AND valid_to IS NULL"
       ),
+      // Attrs twin of findByLabel — same live rows, no embedding blob read.
+      attrsByLabel: this.db.prepare(
+        "SELECT id, created_at, created_at_seq, attrs_json FROM nodes WHERE label = ? AND valid_to IS NULL"
+      ),
       // Identity twin of findByLabel — same live-row semantics, two attrs read in
       // SQL, no attrs JSON.parse or embedding decode (PJ-anchor-reach).
       identitiesByLabel: this.db.prepare(
@@ -16396,8 +16400,16 @@ var SqliteGraphStore = class {
       closeEdge: this.db.prepare(
         "UPDATE edges SET valid_to = :t WHERE id = :id AND valid_to IS NULL"
       ),
+      // Same rows as `COALESCE(logical_id, id) = ?`, split so each branch can use
+      // an index (nodes_logical, then the id primary key). The COALESCE form made
+      // SQLite SCAN nodes: 0.4-0.9s per call on a 227k-node store, once per new
+      // diagnostic via attributeRootCause (2026-09-24).
       nodeHistory: this.db.prepare(
-        "SELECT * FROM nodes WHERE COALESCE(logical_id, id) = ? ORDER BY version ASC"
+        `SELECT * FROM (
+           SELECT * FROM nodes WHERE logical_id = ?1
+           UNION ALL
+           SELECT * FROM nodes WHERE id = ?1 AND logical_id IS NULL
+         ) ORDER BY version ASC`
       ),
       nodesAsOf: this.db.prepare(
         "SELECT * FROM nodes WHERE valid_from <= :t AND (valid_to IS NULL OR valid_to > :t)"
@@ -16648,6 +16660,19 @@ var SqliteGraphStore = class {
   countNodesByLabel(label) {
     return Number(this.stmts.countByLabel.get(label).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
+   *  blob; the liveness watch's coverage pass spent 3.4s of a 4.3s main-thread
+   *  hold doing exactly that on a 227k-node store (2026-09-24). */
+  findNodeAttrsByLabel(label) {
+    const rows = this.stmts.attrsByLabel.all(label);
+    return rows.map((r) => ({
+      id: r.id,
+      createdAt: r.created_at,
+      ...r.created_at_seq != null ? { createdAtSeq: r.created_at_seq } : {},
+      attrs: JSON.parse(r.attrs_json)
+    }));
+  }
   findNodeIdentitiesByLabel(label) {
     const rows = this.stmts.identitiesByLabel.all(label);
     return rows.map((r) => ({
@@ -16712,6 +16737,18 @@ var SqliteGraphStore = class {
     ).all(params);
     return rows.map(rowToEdge);
   }
+  /** Live in-degree per target over `types`, in one grouped query — the counts
+   *  `inEdges(id, types).length` gives, for every node at once. A per-node
+   *  inEdges loop over ~48k code nodes held a PreToolUse hook 12.6s when the
+   *  hotspots vfile materialized (2026-09-24). */
+  inDegreeByType(types) {
+    if (types.length === 0) return /* @__PURE__ */ new Map();
+    const placeholders = types.map(() => "?").join(",");
+    const rows = this.db.prepare(
+      `SELECT to_id, COUNT(*) AS n FROM edges WHERE type IN (${placeholders}) AND valid_to IS NULL GROUP BY to_id`
+    ).all(...types);
+    return new Map(rows.map((r) => [r.to_id, Number(r.n)]));
+  }
   neighbors(nodeId, types) {
     const out = [];
     const edges = this.outEdges(nodeId, types);
@@ -16974,6 +17011,19 @@ var SqliteGraphStore = class {
     const rows = this.stmts.nodesAsOf.all({ t });
     return rows.map(rowToNode);
   }
+  /** `nodesAsOf(t).filter((n) => n.attrs[attr] === true)` with the attr test in
+   *  SQL, so only the flagged rows are hydrated. The filter-after form hydrated
+   *  the whole graph for a handful of revisit flags: 6.7s per context render on
+   *  a 227k-node store (2026-09-24). `attr` is interpolated into a JSON path,
+   *  so it must be a plain identifier. */
+  nodesAsOfWhereTrue(t, attr) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(attr)) throw new Error(`nodesAsOfWhereTrue: bad attr ${JSON.stringify(attr)}`);
+    const rows = this.db.prepare(
+      `SELECT * FROM nodes WHERE valid_from <= :t AND (valid_to IS NULL OR valid_to > :t)
+           AND json_type(attrs_json, '$.${attr}') = 'true'`
+    ).all({ t });
+    return rows.map(rowToNode);
+  }
   edgesAsOf(t) {
     const rows = this.stmts.edgesAsOf.all({ t });
     return rows.map(rowToEdge);

package/errata.mjs

@@ -17703,6 +17703,10 @@ CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.re
           countByLabel: this.db.prepare(
             "SELECT COUNT(*) AS n FROM nodes WHERE label = ? AND valid_to IS NULL"
           ),
+          // Attrs twin of findByLabel — same live rows, no embedding blob read.
+          attrsByLabel: this.db.prepare(
+            "SELECT id, created_at, created_at_seq, attrs_json FROM nodes WHERE label = ? AND valid_to IS NULL"
+          ),
           // Identity twin of findByLabel — same live-row semantics, two attrs read in
           // SQL, no attrs JSON.parse or embedding decode (PJ-anchor-reach).
           identitiesByLabel: this.db.prepare(
@@ -17756,8 +17760,16 @@ CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.re
           closeEdge: this.db.prepare(
             "UPDATE edges SET valid_to = :t WHERE id = :id AND valid_to IS NULL"
           ),
+          // Same rows as `COALESCE(logical_id, id) = ?`, split so each branch can use
+          // an index (nodes_logical, then the id primary key). The COALESCE form made
+          // SQLite SCAN nodes: 0.4-0.9s per call on a 227k-node store, once per new
+          // diagnostic via attributeRootCause (2026-09-24).
           nodeHistory: this.db.prepare(
-            "SELECT * FROM nodes WHERE COALESCE(logical_id, id) = ? ORDER BY version ASC"
+            `SELECT * FROM (
+           SELECT * FROM nodes WHERE logical_id = ?1
+           UNION ALL
+           SELECT * FROM nodes WHERE id = ?1 AND logical_id IS NULL
+         ) ORDER BY version ASC`
           ),
           nodesAsOf: this.db.prepare(
             "SELECT * FROM nodes WHERE valid_from <= :t AND (valid_to IS NULL OR valid_to > :t)"
@@ -18008,6 +18020,19 @@ CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.re
       countNodesByLabel(label) {
         return Number(this.stmts.countByLabel.get(label).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
+       *  blob; the liveness watch's coverage pass spent 3.4s of a 4.3s main-thread
+       *  hold doing exactly that on a 227k-node store (2026-09-24). */
+      findNodeAttrsByLabel(label) {
+        const rows = this.stmts.attrsByLabel.all(label);
+        return rows.map((r) => ({
+          id: r.id,
+          createdAt: r.created_at,
+          ...r.created_at_seq != null ? { createdAtSeq: r.created_at_seq } : {},
+          attrs: JSON.parse(r.attrs_json)
+        }));
+      }
       findNodeIdentitiesByLabel(label) {
         const rows = this.stmts.identitiesByLabel.all(label);
         return rows.map((r) => ({
@@ -18072,6 +18097,18 @@ CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.re
         ).all(params);
         return rows.map(rowToEdge);
       }
+      /** Live in-degree per target over `types`, in one grouped query — the counts
+       *  `inEdges(id, types).length` gives, for every node at once. A per-node
+       *  inEdges loop over ~48k code nodes held a PreToolUse hook 12.6s when the
+       *  hotspots vfile materialized (2026-09-24). */
+      inDegreeByType(types) {
+        if (types.length === 0) return /* @__PURE__ */ new Map();
+        const placeholders = types.map(() => "?").join(",");
+        const rows = this.db.prepare(
+          `SELECT to_id, COUNT(*) AS n FROM edges WHERE type IN (${placeholders}) AND valid_to IS NULL GROUP BY to_id`
+        ).all(...types);
+        return new Map(rows.map((r) => [r.to_id, Number(r.n)]));
+      }
       neighbors(nodeId, types) {
         const out2 = [];
         const edges = this.outEdges(nodeId, types);
@@ -18334,6 +18371,19 @@ CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.re
         const rows = this.stmts.nodesAsOf.all({ t });
         return rows.map(rowToNode);
       }
+      /** `nodesAsOf(t).filter((n) => n.attrs[attr] === true)` with the attr test in
+       *  SQL, so only the flagged rows are hydrated. The filter-after form hydrated
+       *  the whole graph for a handful of revisit flags: 6.7s per context render on
+       *  a 227k-node store (2026-09-24). `attr` is interpolated into a JSON path,
+       *  so it must be a plain identifier. */
+      nodesAsOfWhereTrue(t, attr) {
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(attr)) throw new Error(`nodesAsOfWhereTrue: bad attr ${JSON.stringify(attr)}`);
+        const rows = this.db.prepare(
+          `SELECT * FROM nodes WHERE valid_from <= :t AND (valid_to IS NULL OR valid_to > :t)
+           AND json_type(attrs_json, '$.${attr}') = 'true'`
+        ).all({ t });
+        return rows.map(rowToNode);
+      }
       edgesAsOf(t) {
         const rows = this.stmts.edgesAsOf.all({ t });
         return rows.map(rowToEdge);
@@ -18740,7 +18790,7 @@ function clearRevisit(store, nodeId, ts) {
   store.updateNode(nodeId, { attrs, lastUpdatedAt: ts });
 }
 function listNeedsRevisit(store, asOf) {
-  return store.nodesAsOf(asOf).filter((n) => n.attrs["revisit"] === true).map((n) => ({
+  return store.nodesAsOfWhereTrue(asOf, "revisit").map((n) => ({
     id: n.id,
     label: n.label,
     description: n.description,
@@ -23458,7 +23508,7 @@ function evaluateFed(store, d) {
   const column = COLUMN_INPUTS[d.fed.attr];
   const fed = d.fed;
   const has = (n) => column ? column(n) : n.attrs[fed.attr] !== void 0;
-  const nodes = fed.labels.flatMap((label) => store.findNodesByLabel(label));
+  const nodes = fed.labels.flatMap((label) => store.findNodeAttrsByLabel(label));
   let window2 = nodes;
   if (fed.recent !== void 0) {
     window2 = [...nodes].sort((a, b) => b.createdAt - a.createdAt).slice(0, fed.recent);
@@ -31722,16 +31772,17 @@ function diagnosticKey(relPath, d) {
 function anchorByLine(store, workspaceId2, relPath, line) {
   let best = null;
   let bestRow = -1;
-  for (const label of ["Function", "Method", "Class"]) {
-    for (const n of store.findNodesByLabel(label)) {
-      if (n.attrs["workspaceId"] !== workspaceId2) continue;
-      if (n.attrs["relPath"] !== relPath) continue;
-      const row = n.attrs["startRow"];
-      if (typeof row !== "number" || row > line) continue;
-      if (row > bestRow) {
-        bestRow = row;
-        best = n;
-      }
+  const labelRank = { Function: 0, Method: 1, Class: 2 };
+  for (const n of store.nodesByRelPath([relPath])) {
+    const rank = labelRank[n.label];
+    if (rank === void 0) continue;
+    if (n.attrs["workspaceId"] !== workspaceId2) continue;
+    if (n.attrs["relPath"] !== relPath) continue;
+    const row = n.attrs["startRow"];
+    if (typeof row !== "number" || row > line) continue;
+    if (row > bestRow || row === bestRow && best !== null && rank < labelRank[best.label]) {
+      bestRow = row;
+      best = n;
     }
   }
   return best ? best.logicalId ?? best.id : null;
@@ -42783,7 +42834,8 @@ var init_mcp = __esm({
               items: dead.slice(0, limit)
             };
           }
-          const ranked = codeNodes.map((n) => ({ id: n.id, label: n.label, name: n.description, fanIn: store.inEdges(n.id, [...CODE_REACH_EDGES]).length })).sort((a, b) => b.fanIn - a.fanIn).slice(0, limit);
+          const fanIn = store.inDegreeByType([...CODE_REACH_EDGES]);
+          const ranked = codeNodes.map((n) => ({ id: n.id, label: n.label, name: n.description, fanIn: fanIn.get(n.id) ?? 0 })).sort((a, b) => b.fanIn - a.fanIn).slice(0, limit);
           return { kind: "fan-in", items: ranked };
         }
       },
@@ -78426,7 +78478,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.6-dev.2618" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.6-dev.2627" : "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/package.json

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

package/pass-worker.mjs

@@ -24725,6 +24725,10 @@ var SqliteGraphStore = class {
       countByLabel: this.db.prepare(
         "SELECT COUNT(*) AS n FROM nodes WHERE label = ? AND valid_to IS NULL"
       ),
+      // Attrs twin of findByLabel — same live rows, no embedding blob read.
+      attrsByLabel: this.db.prepare(
+        "SELECT id, created_at, created_at_seq, attrs_json FROM nodes WHERE label = ? AND valid_to IS NULL"
+      ),
       // Identity twin of findByLabel — same live-row semantics, two attrs read in
       // SQL, no attrs JSON.parse or embedding decode (PJ-anchor-reach).
       identitiesByLabel: this.db.prepare(
@@ -24778,8 +24782,16 @@ var SqliteGraphStore = class {
       closeEdge: this.db.prepare(
         "UPDATE edges SET valid_to = :t WHERE id = :id AND valid_to IS NULL"
       ),
+      // Same rows as `COALESCE(logical_id, id) = ?`, split so each branch can use
+      // an index (nodes_logical, then the id primary key). The COALESCE form made
+      // SQLite SCAN nodes: 0.4-0.9s per call on a 227k-node store, once per new
+      // diagnostic via attributeRootCause (2026-09-24).
       nodeHistory: this.db.prepare(
-        "SELECT * FROM nodes WHERE COALESCE(logical_id, id) = ? ORDER BY version ASC"
+        `SELECT * FROM (
+           SELECT * FROM nodes WHERE logical_id = ?1
+           UNION ALL
+           SELECT * FROM nodes WHERE id = ?1 AND logical_id IS NULL
+         ) ORDER BY version ASC`
       ),
       nodesAsOf: this.db.prepare(
         "SELECT * FROM nodes WHERE valid_from <= :t AND (valid_to IS NULL OR valid_to > :t)"
@@ -25030,6 +25042,19 @@ var SqliteGraphStore = class {
   countNodesByLabel(label) {
     return Number(this.stmts.countByLabel.get(label).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
+   *  blob; the liveness watch's coverage pass spent 3.4s of a 4.3s main-thread
+   *  hold doing exactly that on a 227k-node store (2026-09-24). */
+  findNodeAttrsByLabel(label) {
+    const rows = this.stmts.attrsByLabel.all(label);
+    return rows.map((r) => ({
+      id: r.id,
+      createdAt: r.created_at,
+      ...r.created_at_seq != null ? { createdAtSeq: r.created_at_seq } : {},
+      attrs: JSON.parse(r.attrs_json)
+    }));
+  }
   findNodeIdentitiesByLabel(label) {
     const rows = this.stmts.identitiesByLabel.all(label);
     return rows.map((r) => ({
@@ -25094,6 +25119,18 @@ var SqliteGraphStore = class {
     ).all(params);
     return rows.map(rowToEdge);
   }
+  /** Live in-degree per target over `types`, in one grouped query — the counts
+   *  `inEdges(id, types).length` gives, for every node at once. A per-node
+   *  inEdges loop over ~48k code nodes held a PreToolUse hook 12.6s when the
+   *  hotspots vfile materialized (2026-09-24). */
+  inDegreeByType(types) {
+    if (types.length === 0) return /* @__PURE__ */ new Map();
+    const placeholders = types.map(() => "?").join(",");
+    const rows = this.db.prepare(
+      `SELECT to_id, COUNT(*) AS n FROM edges WHERE type IN (${placeholders}) AND valid_to IS NULL GROUP BY to_id`
+    ).all(...types);
+    return new Map(rows.map((r) => [r.to_id, Number(r.n)]));
+  }
   neighbors(nodeId, types) {
     const out2 = [];
     const edges = this.outEdges(nodeId, types);
@@ -25356,6 +25393,19 @@ var SqliteGraphStore = class {
     const rows = this.stmts.nodesAsOf.all({ t });
     return rows.map(rowToNode);
   }
+  /** `nodesAsOf(t).filter((n) => n.attrs[attr] === true)` with the attr test in
+   *  SQL, so only the flagged rows are hydrated. The filter-after form hydrated
+   *  the whole graph for a handful of revisit flags: 6.7s per context render on
+   *  a 227k-node store (2026-09-24). `attr` is interpolated into a JSON path,
+   *  so it must be a plain identifier. */
+  nodesAsOfWhereTrue(t, attr) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(attr)) throw new Error(`nodesAsOfWhereTrue: bad attr ${JSON.stringify(attr)}`);
+    const rows = this.db.prepare(
+      `SELECT * FROM nodes WHERE valid_from <= :t AND (valid_to IS NULL OR valid_to > :t)
+           AND json_type(attrs_json, '$.${attr}') = 'true'`
+    ).all({ t });
+    return rows.map(rowToNode);
+  }
   edgesAsOf(t) {
     const rows = this.stmts.edgesAsOf.all({ t });
     return rows.map(rowToEdge);
@@ -25471,7 +25521,7 @@ function clearRevisit(store2, nodeId, ts) {
   store2.updateNode(nodeId, { attrs, lastUpdatedAt: ts });
 }
 function listNeedsRevisit(store2, asOf) {
-  return store2.nodesAsOf(asOf).filter((n) => n.attrs["revisit"] === true).map((n) => ({
+  return store2.nodesAsOfWhereTrue(asOf, "revisit").map((n) => ({
     id: n.id,
     label: n.label,
     description: n.description,