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

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;
@@ -16957,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(",");

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;
@@ -18317,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(",");
@@ -19303,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) {
@@ -19315,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)) {
@@ -24052,6 +24087,8 @@ __export(src_exports2, {
   stampObservedOs: () => stampObservedOs,
   statementIdentityKey: () => statementIdentityKey,
   staticConductance: () => staticConductance,
+  symbolCandidatesInText: () => symbolCandidatesInText,
+  symbolIndexForText: () => symbolIndexForText,
   toolNodeId: () => toolNodeId,
   toolPriorsFor: () => toolPriorsFor,
   triageOf: () => triageOf,
@@ -78478,7 +78515,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.6-dev.2627" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.6-dev.2635" : "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;
@@ -82211,26 +82248,40 @@ function classifyAnchorVersion(cloudAttrs, localSymbol) {
   return seen === have ? "current" : "pre-change";
 }
 function buildReverseSymbolMap(opts) {
+  return collectFirstWins(reverseSymbolEntries(opts));
+}
+function* reverseSymbolEntries(opts) {
   const { store, salt, projectId } = opts;
-  const reverse = /* @__PURE__ */ new Map();
   for (const kind of ANCHOR_SYMBOL_KINDS2) {
     for (const n of store.findNodeIdentitiesByLabel(kind)) {
       const { relPath, qname } = n;
       if (relPath === null || qname === null) continue;
       const sym = projectSymbolId(salt, projectId, relPath, qname, kind);
-      if (!reverse.has(sym)) reverse.set(sym, n.id);
-      const twin = projectSaltedNodeId(sym, salt);
-      if (!reverse.has(twin)) reverse.set(twin, n.id);
+      yield [sym, n.id];
+      yield [projectSaltedNodeId(sym, salt), n.id];
     }
   }
   for (const n of store.findNodeIdentitiesByLabel("File")) {
     if (n.relPath === null) continue;
     const sym = projectSymbolId(salt, projectId, n.relPath, FILE_ANCHOR_QNAME, "File");
-    if (!reverse.has(sym)) reverse.set(sym, n.id);
-    const twin = projectSaltedNodeId(sym, salt);
-    if (!reverse.has(twin)) reverse.set(twin, n.id);
+    yield [sym, n.id];
+    yield [projectSaltedNodeId(sym, salt), n.id];
+  }
+}
+function collectFirstWins(entries) {
+  const m = /* @__PURE__ */ new Map();
+  for (const [k, v] of entries) if (!m.has(k)) m.set(k, v);
+  return m;
+}
+var MAP_BUILD_BATCH = 2e3;
+async function collectFirstWinsYielding(entries) {
+  const m = /* @__PURE__ */ new Map();
+  let i2 = 0;
+  for (const [k, v] of entries) {
+    if (++i2 % MAP_BUILD_BATCH === 0) await new Promise((r) => setImmediate(r));
+    if (!m.has(k)) m.set(k, v);
   }
-  return reverse;
+  return m;
 }
 function anchorConfidence(attrs) {
   const v = typeof attrs["extractionConfidence"] === "number" ? attrs["extractionConfidence"] : attrs["confidence"];
@@ -82245,15 +82296,25 @@ var ANCHOR_SOURCE_KINDS = [
   "AntiPattern"
 ];
 function buildOwnKnowledgeMap(opts) {
+  return new Map(ownKnowledgeEntries(opts));
+}
+function* ownKnowledgeEntries(opts) {
   const { store, salt } = opts;
-  const own = /* @__PURE__ */ new Map();
   for (const kind of ANCHOR_SOURCE_KINDS) {
     for (const n of store.findNodeIdentitiesByLabel(kind)) {
       if (n.id.startsWith("projn_")) continue;
-      own.set(projectSaltedNodeId(n.id, salt), n.id);
+      yield [projectSaltedNodeId(n.id, salt), n.id];
     }
   }
-  return own;
+}
+async function collectLastWinsYielding(entries) {
+  const m = /* @__PURE__ */ new Map();
+  let i2 = 0;
+  for (const [k, v] of entries) {
+    if (++i2 % MAP_BUILD_BATCH === 0) await new Promise((r) => setImmediate(r));
+    m.set(k, v);
+  }
+  return m;
 }
 function resolveAnchorSource(store, from, own) {
   if (store.getNode(from)) return from;
@@ -82266,30 +82327,27 @@ function existingAnchor(store, from, to) {
 var reverseCache = /* @__PURE__ */ new WeakMap();
 var ownCache = /* @__PURE__ */ new WeakMap();
 function cachedMap(cache2, store, key, build) {
-  let refreshed = false;
+  let rebuild = null;
   const put = () => {
-    const map2 = build();
-    cache2.set(store, { key, map: map2 });
-    return map2;
+    rebuild ??= build().then((map2) => {
+      cache2.set(store, { key, map: map2 });
+      return map2;
+    });
+    return rebuild;
   };
   return {
-    get: () => {
+    get: async () => {
       const hit = cache2.get(store);
       if (hit && hit.key === key) return hit.map;
-      refreshed = true;
       return put();
     },
-    refresh: () => {
-      if (refreshed) return cache2.get(store)?.map ?? put();
-      refreshed = true;
-      return put();
-    }
+    refresh: () => put()
   };
 }
-function lookupLive(store, m, id) {
-  const first = m.get().get(id);
+async function lookupLive(store, m, id) {
+  const first = (await m.get()).get(id);
   if (first && isLive2(store, first)) return first;
-  const second = m.refresh().get(id);
+  const second = (await m.refresh()).get(id);
   return second && isLive2(store, second) ? second : null;
 }
 function isLive2(store, id) {
@@ -82370,8 +82428,13 @@ async function syncProjectAnchors(opts) {
   if (!profile.projectId) return { synced: false, reason: "no-project" };
   const projectId = profile.projectId;
   const key = `${projectId}|${salt}`;
-  const reverse = cachedMap(reverseCache, store, key, () => buildReverseSymbolMap({ store, salt, projectId }));
-  const own = cachedMap(ownCache, store, salt, () => buildOwnKnowledgeMap({ store, salt }));
+  const reverse = cachedMap(
+    reverseCache,
+    store,
+    key,
+    () => collectFirstWinsYielding(reverseSymbolEntries({ store, salt, projectId }))
+  );
+  const own = cachedMap(ownCache, store, salt, () => collectLastWinsYielding(ownKnowledgeEntries({ store, salt })));
   const limit = opts.limit ?? SYNC_PAGE;
   const maxPages = opts.maxPages ?? SYNC_MAX_PAGES;
   let anchors = 0;
@@ -82383,19 +82446,19 @@ async function syncProjectAnchors(opts) {
     for (let page = 0; page < maxPages; page++) {
       const res = await cloud.getProjectAnchors(projectId, cursor, limit);
       if (res.anchors.length === 0) break;
-      if (reverse.get().size === 0 && reverse.refresh().size === 0) {
+      if ((await reverse.get()).size === 0 && (await reverse.refresh()).size === 0) {
         return { synced: false, reason: "no-local-symbols" };
       }
       const byId = new Map(res.nodes.map((n) => [n.id, n]));
       const now = Date.now();
       for (const a of res.anchors) {
         if (a.type !== "ANCHORED_AT") continue;
-        const localTo = lookupLive(store, reverse, a.toSymbolId);
+        const localTo = await lookupLive(store, reverse, a.toSymbolId);
         if (!localTo) {
           dropped++;
           continue;
         }
-        let from = store.getNode(a.from) ? a.from : lookupLive(store, own, a.from);
+        let from = store.getNode(a.from) ? a.from : await lookupLive(store, own, a.from);
         if (!from) {
           const node2 = byId.get(a.from);
           if (!node2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.6-dev.2627",
+  "version": "2.0.6-dev.2635",
   "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;
@@ -25339,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(",");