@inerrata-corporation/errata 2.0.17-dev.3549 → 2.0.17-dev.3562

package/consolidate-worker.mjs

@@ -16611,6 +16611,7 @@ function rowToEdge(r) {
   };
 }
 var FINGERPRINT_INDEXED_LABELS = ["Problem", "Vulnerability", "Solution", "RootCause"];
+var NODE_LABELS_CHUNK = 256;
 var SqliteGraphStore = class {
   db;
   // Typed edge lookups build their SQL from the number of types asked for, and
@@ -17113,6 +17114,19 @@ var SqliteGraphStore = class {
     const row = this.stmts.getNode.get(id);
     return row ? rowToNode(row) : null;
   }
+  nodeLabels(ids) {
+    const width = NODE_LABELS_CHUNK;
+    const stmt = this.typedEdgeStmt(
+      `SELECT id, label FROM nodes WHERE id IN (${Array.from({ length: width }, () => "?").join(",")})`
+    );
+    const labels = /* @__PURE__ */ new Map();
+    for (let i = 0; i < ids.length; i += width) {
+      const chunk = ids.slice(i, i + width);
+      while (chunk.length < width) chunk.push(null);
+      for (const row of stmt.all(...chunk)) labels.set(row.id, row.label);
+    }
+    return labels;
+  }
   getEdge(id) {
     const row = this.stmts.getEdge.get(id);
     return row ? rowToEdge(row) : null;

package/errata.mjs

@@ -18445,7 +18445,7 @@ function rowToEdge(r) {
 function openGraphStore(opts) {
   return new SqliteGraphStore(opts);
 }
-var LOCAL_RULE_OVERRIDES, SCHEMA_VERSION, SESSION_REPAIR_KEY, SESSION_EVIDENCE_PREDICATE, SCHEMA_SQL, TEMPORAL_INDEX_SQL, FINGERPRINT_INDEXED_LABELS, SqliteGraphStore;
+var LOCAL_RULE_OVERRIDES, SCHEMA_VERSION, SESSION_REPAIR_KEY, SESSION_EVIDENCE_PREDICATE, SCHEMA_SQL, TEMPORAL_INDEX_SQL, FINGERPRINT_INDEXED_LABELS, NODE_LABELS_CHUNK, SqliteGraphStore;
 var init_store = __esm({
   "../../packages/local-graph/src/store.ts"() {
     "use strict";
@@ -18596,6 +18596,7 @@ CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) W
 CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path ON nodes(json_extract(attrs_json, '$.anchorHint.path')) WHERE valid_to IS NULL;
 `;
     FINGERPRINT_INDEXED_LABELS = ["Problem", "Vulnerability", "Solution", "RootCause"];
+    NODE_LABELS_CHUNK = 256;
     SqliteGraphStore = class {
       db;
       // Typed edge lookups build their SQL from the number of types asked for, and
@@ -19098,6 +19099,19 @@ CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path ON nodes(json_extract(attrs_js
         const row = this.stmts.getNode.get(id);
         return row ? rowToNode(row) : null;
       }
+      nodeLabels(ids) {
+        const width = NODE_LABELS_CHUNK;
+        const stmt = this.typedEdgeStmt(
+          `SELECT id, label FROM nodes WHERE id IN (${Array.from({ length: width }, () => "?").join(",")})`
+        );
+        const labels = /* @__PURE__ */ new Map();
+        for (let i2 = 0; i2 < ids.length; i2 += width) {
+          const chunk = ids.slice(i2, i2 + width);
+          while (chunk.length < width) chunk.push(null);
+          for (const row of stmt.all(...chunk)) labels.set(row.id, row.label);
+        }
+        return labels;
+      }
       getEdge(id) {
         const row = this.stmts.getEdge.get(id);
         return row ? rowToEdge(row) : null;
@@ -19600,7 +19614,9 @@ function staticConductance(edgeType) {
   return Math.max(UNKNOWN_CONDUCTANCE, Math.min(1, w / MAX_EDGE_WEIGHT));
 }
 function edgeConductance(edge2) {
-  const staticW = staticConductance(edge2.type);
+  return learnedConductance(staticConductance(edge2.type), edge2);
+}
+function learnedConductance(staticW, edge2) {
   const s = edge2.navSuccesses ?? 0;
   const f = edge2.navFailures ?? 0;
   const betaMean = (1 + s) / (2 + s + f);
@@ -22800,9 +22816,28 @@ var init_uncertainty = __esm({
 });
 
 // ../../packages/math/src/discovery.ts
+function typeRelevance(label) {
+  return TYPE_RELEVANCE[label] ?? DEFAULT_TYPE_RELEVANCE;
+}
+var TYPE_RELEVANCE, DEFAULT_TYPE_RELEVANCE;
 var init_discovery = __esm({
   "../../packages/math/src/discovery.ts"() {
     "use strict";
+    TYPE_RELEVANCE = {
+      Solution: 1,
+      Vulnerability: 0.95,
+      RootCause: 0.9,
+      Pattern: 0.8,
+      Problem: 0.7,
+      Technique: 0.7,
+      AntiPattern: 0.7,
+      Weakness: 0.6,
+      Domain: 0.5,
+      Function: 0.4,
+      Class: 0.4,
+      File: 0.3
+    };
+    DEFAULT_TYPE_RELEVANCE = 0.3;
   }
 });
 
@@ -25340,6 +25375,7 @@ __export(src_exports2, {
   isFragmentFixNote: () => isFragmentFixNote,
   isPlaceholderStatement: () => isPlaceholderStatement,
   isUnfilledPlaceholder: () => isUnfilledPlaceholder,
+  learnedConductance: () => learnedConductance,
   linkProblemToLanguages: () => linkProblemToLanguages,
   linkProblemToPackages: () => linkProblemToPackages,
   linkProblemToSymbols: () => linkProblemToSymbols,
@@ -32175,62 +32211,139 @@ async function rankForText(store, text, candidateIds) {
     (r) => r.score > 0
   );
 }
+function walksRelatedness(type) {
+  if (type === "DEPENDS_ON") return true;
+  if (PAGERANK_EXCLUSIONS.has(type)) return false;
+  return (EDGE_WEIGHT[type] ?? 1) > 0;
+}
+function burstStaticConductance(type, seedLabel) {
+  if (type === "ANCHORED_AT") return BURST_ANCHORED_AT_CONDUCTANCE;
+  if (type === "DEPENDS_ON") return seedLabel === "Package" ? staticConductance(type) : BURST_DEPENDS_ON_FLOOR;
+  return staticConductance(type);
+}
+function burstConductance(edge2, seedLabel) {
+  return learnedConductance(burstStaticConductance(edge2.type, seedLabel), edge2);
+}
 function localBurst(store, seedId, opts = {}) {
-  const maxHops = opts.maxHops ?? 2;
+  const maxHops = opts.maxHops ?? 3;
   const limit = opts.limit ?? 20;
-  const nodeCap = opts.nodeCap ?? 500;
+  const nodeCap = opts.nodeCap ?? 200;
   const seed = store.getNode(seedId);
   if (!seed) return [];
+  const act = /* @__PURE__ */ new Map([[seedId, 1]]);
   const hopOf = /* @__PURE__ */ new Map([[seedId, 0]]);
   const viaOf = /* @__PURE__ */ new Map();
-  let frontier = [seedId];
-  for (let h = 1; h <= maxHops && hopOf.size < nodeCap; h++) {
-    const next = [];
-    for (const id of frontier) {
-      const neigh = [
-        ...store.outEdges(id).map((e) => ({ nb: e.to, via: { edgeType: e.type, parentId: id, forward: true } })),
-        ...store.inEdges(id).map((e) => ({ nb: e.from, via: { edgeType: e.type, parentId: id, forward: false } }))
-      ];
-      for (const { nb, via } of neigh) {
-        if (!hopOf.has(nb)) {
-          hopOf.set(nb, h);
-          viaOf.set(nb, via);
-          next.push(nb);
-          if (hopOf.size >= nodeCap) break;
-        }
-      }
-      if (hopOf.size >= nodeCap) break;
-    }
-    frontier = next;
-  }
-  hopOf.delete(seedId);
+  const expanded = /* @__PURE__ */ new Set();
+  const frontier = new ActivationHeap();
+  frontier.push(seedId, 1);
+  let strongest = 0;
+  while (frontier.size > 0 && expanded.size < nodeCap) {
+    const top = frontier.pop();
+    if (expanded.has(top.id) || top.a < (act.get(top.id) ?? 0)) continue;
+    if (top.a < ACTIVATION_EPSILON || top.a < strongest * BURST_RELATIVE_FLOOR) break;
+    expanded.add(top.id);
+    const hops = hopOf.get(top.id) ?? 0;
+    if (hops >= maxHops) continue;
+    const edges = [
+      ...store.outEdges(top.id).map((e) => ({ e, nb: e.to, forward: true })),
+      ...store.inEdges(top.id).map((e) => ({ e, nb: e.from, forward: false }))
+    ].filter(({ e }) => walksRelatedness(e.type));
+    const damp = BURST_STEP_DAMPING / Math.sqrt(Math.max(1, edges.length));
+    for (const { e, nb, forward } of edges) {
+      if (nb === seedId || expanded.has(nb)) continue;
+      const a = top.a * burstConductance(e, seed.label) * damp;
+      if (a <= (act.get(nb) ?? 0)) continue;
+      act.set(nb, a);
+      if (a > strongest) strongest = a;
+      hopOf.set(nb, hops + 1);
+      viaOf.set(nb, { edgeType: e.type, parentId: top.id, forward });
+      frontier.push(nb, a);
+    }
+  }
+  act.delete(seedId);
   const ctxSeed = seed.embedding.length > 0 ? { seedEmbedding: seed.embedding, seedEmbeddingVersion: seed.attrs["embeddingVersion"] } : {};
   const gated = seed.embedding.length > 0;
-  const nodes = [...hopOf.entries()].map(([id, hops]) => ({ node: store.getNode(id), hops })).filter((x) => x.node != null);
-  const maxPr = Math.max(1e-9, ...nodes.map((x) => x.node.pageRank));
+  const labelOf = store.nodeLabels([...act.keys()]);
+  const pool = (keep) => [...act.entries()].filter(([id]) => keep(labelOf.get(id) ?? "")).sort((x, y) => y[1] - x[1]).slice(0, BURST_SCORED_CANDIDATES);
+  const isKnowledge = (label) => typeRelevance(label) >= KNOWLEDGE_TYPE_RELEVANCE;
+  const reached = [...pool(isKnowledge), ...pool((l) => !isKnowledge(l))].map(([id, a]) => ({ node: store.getNode(id), a })).filter((x) => x.node != null);
+  const maxPr = Math.max(1e-9, ...reached.map((x) => x.node.pageRank));
+  const maxAct = Math.max(1e-12, ...reached.map((x) => x.a));
   const weights = {
     centralityScale: maxPr,
     ...gated ? { semanticFloor: semanticFloorFor(ctxSeed.seedEmbeddingVersion) } : {},
     ...opts.weights
   };
   const now = store.currentIngestSeq();
-  return nodes.map(({ node: node2, hops }) => {
-    const r = scoreCandidate(node2, { ...ctxSeed, hops, decay: nodeFreshness(node2, now) }, weights);
+  return reached.map(({ node: node2, a }) => {
+    const r = scoreCandidate(node2, { ...ctxSeed, decay: nodeFreshness(node2, now) }, weights);
+    const score2 = a / maxAct * r.score * typeRelevance(node2.label);
     const via = viaOf.get(node2.id);
-    return { id: node2.id, score: r.score, components: r.components, node: node2, hops, ...via ? { via } : {} };
+    return { id: node2.id, score: score2, components: r.components, node: node2, hops: hopOf.get(node2.id) ?? 0, ...via ? { via } : {} };
   }).filter((r) => !gated || r.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
 }
+var BURST_STEP_DAMPING, ACTIVATION_EPSILON, BURST_RELATIVE_FLOOR, BURST_SCORED_CANDIDATES, KNOWLEDGE_TYPE_RELEVANCE, BURST_ANCHORED_AT_CONDUCTANCE, BURST_DEPENDS_ON_FLOOR, ActivationHeap;
 var init_relevance_rank = __esm({
   "../../packages/generalizer/src/relevance-rank.ts"() {
     "use strict";
     init_src3();
     init_src4();
+    init_src5();
+    init_src();
+    BURST_STEP_DAMPING = 0.85;
+    ACTIVATION_EPSILON = 1e-6;
+    BURST_RELATIVE_FLOOR = 0.02;
+    BURST_SCORED_CANDIDATES = 150;
+    KNOWLEDGE_TYPE_RELEVANCE = 0.5;
+    BURST_ANCHORED_AT_CONDUCTANCE = 1 / 3;
+    BURST_DEPENDS_ON_FLOOR = 0.1;
+    ActivationHeap = class {
+      items = [];
+      get size() {
+        return this.items.length;
+      }
+      push(id, a) {
+        const items = this.items;
+        items.push({ id, a });
+        let i2 = items.length - 1;
+        while (i2 > 0) {
+          const p = i2 - 1 >> 1;
+          if (items[p].a >= items[i2].a) break;
+          [items[p], items[i2]] = [items[i2], items[p]];
+          i2 = p;
+        }
+      }
+      pop() {
+        const items = this.items;
+        const top = items[0];
+        const last = items.pop();
+        if (items.length > 0 && last) {
+          items[0] = last;
+          let i2 = 0;
+          for (; ; ) {
+            const l = 2 * i2 + 1, r = l + 1;
+            let m = i2;
+            if (l < items.length && items[l].a > items[m].a) m = l;
+            if (r < items.length && items[r].a > items[m].a) m = r;
+            if (m === i2) break;
+            [items[m], items[i2]] = [items[i2], items[m]];
+            i2 = m;
+          }
+        }
+        return top;
+      }
+    };
   }
 });
 
 // ../../packages/generalizer/src/index.ts
 var src_exports3 = {};
 __export(src_exports3, {
+  BURST_ANCHORED_AT_CONDUCTANCE: () => BURST_ANCHORED_AT_CONDUCTANCE,
+  BURST_DEPENDS_ON_FLOOR: () => BURST_DEPENDS_ON_FLOOR,
+  BURST_RELATIVE_FLOOR: () => BURST_RELATIVE_FLOOR,
+  BURST_SCORED_CANDIDATES: () => BURST_SCORED_CANDIDATES,
+  BURST_STEP_DAMPING: () => BURST_STEP_DAMPING,
   FULL_RESCORE_EVERY: () => FULL_RESCORE_EVERY,
   INCREMENTAL_REGION_MAX_FRACTION: () => INCREMENTAL_REGION_MAX_FRACTION,
   anchorByLine: () => anchorByLine,
@@ -32240,6 +32353,8 @@ __export(src_exports3, {
   attributeRootCause: () => attributeRootCause,
   bindCanonicalNeighbors: () => bindCanonicalNeighbors,
   bindResolvedRegressions: () => bindResolvedRegressions,
+  burstConductance: () => burstConductance,
+  burstStaticConductance: () => burstStaticConductance,
   closeProblem: () => closeProblem,
   codeAnchorProjection: () => codeAnchorProjection,
   commandSignature: () => commandSignature,
@@ -82519,7 +82634,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.17-dev.3549" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.17-dev.3562" : "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.17-dev.3549",
+  "version": "2.0.17-dev.3562",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {

package/pass-worker.mjs

@@ -25640,6 +25640,7 @@ function rowToEdge(r) {
   };
 }
 var FINGERPRINT_INDEXED_LABELS = ["Problem", "Vulnerability", "Solution", "RootCause"];
+var NODE_LABELS_CHUNK = 256;
 var SqliteGraphStore = class {
   db;
   // Typed edge lookups build their SQL from the number of types asked for, and
@@ -26142,6 +26143,19 @@ var SqliteGraphStore = class {
     const row = this.stmts.getNode.get(id);
     return row ? rowToNode(row) : null;
   }
+  nodeLabels(ids) {
+    const width = NODE_LABELS_CHUNK;
+    const stmt = this.typedEdgeStmt(
+      `SELECT id, label FROM nodes WHERE id IN (${Array.from({ length: width }, () => "?").join(",")})`
+    );
+    const labels = /* @__PURE__ */ new Map();
+    for (let i2 = 0; i2 < ids.length; i2 += width) {
+      const chunk = ids.slice(i2, i2 + width);
+      while (chunk.length < width) chunk.push(null);
+      for (const row of stmt.all(...chunk)) labels.set(row.id, row.label);
+    }
+    return labels;
+  }
   getEdge(id) {
     const row = this.stmts.getEdge.get(id);
     return row ? rowToEdge(row) : null;
@@ -28965,6 +28979,10 @@ function codeAnchorProjection(store2, semanticIds, opts = {}) {
 // ../../packages/generalizer/src/embed-code.ts
 init_src();
 
+// ../../packages/generalizer/src/relevance-rank.ts
+init_src();
+var BURST_ANCHORED_AT_CONDUCTANCE = 1 / 3;
+
 // ../../packages/context-writer/src/agents-md.ts
 init_src();