@inerrata-corporation/errata 2.0.6-dev.2621 → 2.0.6-dev.2632

package/consolidate-worker.mjs

@@ -16143,6 +16143,9 @@ CREATE INDEX IF NOT EXISTS edges_live ON edges(valid_to);
 -- incremental reindex can fetch just the changed files' symbols instead of
 -- scanning every versioned node. Partial: only live rows are ever queried.
 CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.relPath')) WHERE valid_to IS NULL;
+-- Live rows by name, for looking up the few symbols a statement mentions
+-- instead of hydrating every code symbol per minted problem.
+CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) WHERE valid_to IS NULL;
 `;
 function encodeEmbedding(emb) {
   if (!emb || emb.length === 0) return null;
@@ -16400,8 +16403,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)"
@@ -16729,6 +16740,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);
@@ -16937,6 +16960,21 @@ var SqliteGraphStore = class {
   /** Live nodes whose attrs.relPath is one of `relPaths`. Uses the nodes_relpath
    *  expression index so the incremental reindex fetches only the changed files'
    *  symbols instead of scanning every versioned node. */
+  /** Live nodes of `labels` whose description is exactly one of `names`, via
+   *  the nodes_live_description index. Chunked under the bound-parameter cap. */
+  liveNodesByDescription(names, labels) {
+    if (names.length === 0 || labels.length === 0) return [];
+    const out = [];
+    const labelPh = labels.map(() => "?").join(",");
+    for (let i = 0; i < names.length; i += 400) {
+      const chunk = names.slice(i, i + 400);
+      const rows = this.db.prepare(
+        `SELECT * FROM nodes WHERE valid_to IS NULL AND description IN (${chunk.map(() => "?").join(",")}) AND label IN (${labelPh})`
+      ).all(...chunk, ...labels);
+      for (const r of rows) out.push(rowToNode(r));
+    }
+    return out;
+  }
   nodesByRelPath(relPaths) {
     if (relPaths.length === 0) return [];
     const placeholders = relPaths.map(() => "?").join(",");
@@ -16991,6 +17029,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

@@ -17560,6 +17560,9 @@ CREATE INDEX IF NOT EXISTS edges_live ON edges(valid_to);
 -- incremental reindex can fetch just the changed files' symbols instead of
 -- scanning every versioned node. Partial: only live rows are ever queried.
 CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.relPath')) WHERE valid_to IS NULL;
+-- Live rows by name, for looking up the few symbols a statement mentions
+-- instead of hydrating every code symbol per minted problem.
+CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) WHERE valid_to IS NULL;
 `;
     SqliteGraphStore = class {
       db;
@@ -17760,8 +17763,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)"
@@ -18089,6 +18100,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);
@@ -18297,6 +18320,21 @@ CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.re
       /** Live nodes whose attrs.relPath is one of `relPaths`. Uses the nodes_relpath
        *  expression index so the incremental reindex fetches only the changed files'
        *  symbols instead of scanning every versioned node. */
+      /** Live nodes of `labels` whose description is exactly one of `names`, via
+       *  the nodes_live_description index. Chunked under the bound-parameter cap. */
+      liveNodesByDescription(names, labels) {
+        if (names.length === 0 || labels.length === 0) return [];
+        const out2 = [];
+        const labelPh = labels.map(() => "?").join(",");
+        for (let i2 = 0; i2 < names.length; i2 += 400) {
+          const chunk = names.slice(i2, i2 + 400);
+          const rows = this.db.prepare(
+            `SELECT * FROM nodes WHERE valid_to IS NULL AND description IN (${chunk.map(() => "?").join(",")}) AND label IN (${labelPh})`
+          ).all(...chunk, ...labels);
+          for (const r of rows) out2.push(rowToNode(r));
+        }
+        return out2;
+      }
       nodesByRelPath(relPaths) {
         if (relPaths.length === 0) return [];
         const placeholders = relPaths.map(() => "?").join(",");
@@ -18351,6 +18389,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);
@@ -18757,7 +18808,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,
@@ -19270,6 +19321,33 @@ function buildSymbolIndex(store) {
   }
   return idx;
 }
+function symbolCandidatesInText(text) {
+  const out2 = /* @__PURE__ */ new Set();
+  for (const run3 of text.match(/[\w$.]+/g) ?? []) {
+    const segs = run3.split(".");
+    for (let i2 = 0; i2 < segs.length; i2++) {
+      if (!segs[i2]) continue;
+      let name2 = "";
+      for (let j = i2; j < segs.length && segs[j]; j++) {
+        name2 = j === i2 ? segs[j] : `${name2}.${segs[j]}`;
+        if (isShapedSymbol(name2)) out2.add(name2);
+      }
+    }
+  }
+  return [...out2];
+}
+function symbolIndexForText(store, text) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const n of store.liveNodesByDescription(symbolCandidatesInText(text), SYMBOL_LABELS)) {
+    const name2 = n.description.trim();
+    const list = counts.get(name2);
+    if (list) list.push(n);
+    else counts.set(name2, [n]);
+  }
+  const idx = /* @__PURE__ */ new Map();
+  for (const [name2, nodes] of counts) if (nodes.length === 1) idx.set(name2, nodes[0]);
+  return idx;
+}
 function matchSymbolsInText(text, index) {
   const out2 = [];
   for (const [name2, node2] of index) {
@@ -19282,19 +19360,9 @@ function matchSymbolsInText(text, index) {
 function linkProblemToSymbols(store, problemId, text, ts, index) {
   const p = store.getNode(problemId);
   if (!p || p.label !== "Problem") return [];
-  const idx = index ?? buildSymbolIndex(store);
+  const idx = index ?? symbolIndexForText(store, text);
   if (idx.size === 0) return [];
-  let fileByPath = null;
-  const fileFor2 = (relPath) => {
-    if (!fileByPath) {
-      fileByPath = /* @__PURE__ */ new Map();
-      for (const f of store.findNodesByLabel("File")) {
-        const rp = String(f.attrs["relPath"] ?? f.description ?? "");
-        if (rp) fileByPath.set(rp, f);
-      }
-    }
-    return fileByPath.get(relPath) ?? null;
-  };
+  const fileFor2 = (relPath) => store.nodesByRelPath([relPath]).find((f) => f.label === "File") ?? null;
   const already = new Set(store.outEdges(problemId, ["ANCHORED_AT"]).map((e) => e.to));
   const linked = [];
   for (const sym of matchSymbolsInText(text, idx)) {
@@ -24019,6 +24087,8 @@ __export(src_exports2, {
   stampObservedOs: () => stampObservedOs,
   statementIdentityKey: () => statementIdentityKey,
   staticConductance: () => staticConductance,
+  symbolCandidatesInText: () => symbolCandidatesInText,
+  symbolIndexForText: () => symbolIndexForText,
   toolNodeId: () => toolNodeId,
   toolPriorsFor: () => toolPriorsFor,
   triageOf: () => triageOf,
@@ -31739,16 +31809,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;
@@ -42800,7 +42871,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 };
         }
       },
@@ -78443,7 +78515,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.6-dev.2621" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.6-dev.2632" : "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.2621",
+  "version": "2.0.6-dev.2632",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {

package/pass-worker.mjs

@@ -24525,6 +24525,9 @@ CREATE INDEX IF NOT EXISTS edges_live ON edges(valid_to);
 -- incremental reindex can fetch just the changed files' symbols instead of
 -- scanning every versioned node. Partial: only live rows are ever queried.
 CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.relPath')) WHERE valid_to IS NULL;
+-- Live rows by name, for looking up the few symbols a statement mentions
+-- instead of hydrating every code symbol per minted problem.
+CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) WHERE valid_to IS NULL;
 `;
 function encodeEmbedding(emb) {
   if (!emb || emb.length === 0) return null;
@@ -24782,8 +24785,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)"
@@ -25111,6 +25122,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);
@@ -25319,6 +25342,21 @@ var SqliteGraphStore = class {
   /** Live nodes whose attrs.relPath is one of `relPaths`. Uses the nodes_relpath
    *  expression index so the incremental reindex fetches only the changed files'
    *  symbols instead of scanning every versioned node. */
+  /** Live nodes of `labels` whose description is exactly one of `names`, via
+   *  the nodes_live_description index. Chunked under the bound-parameter cap. */
+  liveNodesByDescription(names, labels) {
+    if (names.length === 0 || labels.length === 0) return [];
+    const out2 = [];
+    const labelPh = labels.map(() => "?").join(",");
+    for (let i2 = 0; i2 < names.length; i2 += 400) {
+      const chunk = names.slice(i2, i2 + 400);
+      const rows = this.db.prepare(
+        `SELECT * FROM nodes WHERE valid_to IS NULL AND description IN (${chunk.map(() => "?").join(",")}) AND label IN (${labelPh})`
+      ).all(...chunk, ...labels);
+      for (const r of rows) out2.push(rowToNode(r));
+    }
+    return out2;
+  }
   nodesByRelPath(relPaths) {
     if (relPaths.length === 0) return [];
     const placeholders = relPaths.map(() => "?").join(",");
@@ -25373,6 +25411,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);
@@ -25488,7 +25539,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,