@inerrata-corporation/errata 2.0.21 → 2.0.22-dev.4049

package/consolidate-worker.mjs

@@ -594,6 +594,13 @@ function aliasRegex(alias) {
   const body = escapeRe(alias).replace(/\\?\s+/g, "\\s+");
   return new RegExp(`(?<![\\w-])${body}(?![\\w-])`, "i");
 }
+function withoutEntityMentions(text, entityId) {
+  let out = text;
+  for (const { entity, re } of COMPILED) {
+    if (entity.id === entityId) out = out.replace(new RegExp(re.source, "gi"), " ");
+  }
+  return out;
+}
 function prefilterEntities(text) {
   const seen = /* @__PURE__ */ new Set();
   const hits = [];
@@ -770,13 +777,19 @@ var init_concept_bag = __esm({
 
 // ../../packages/shared/src/nlp/claim-id.ts
 function claimStructure(text, scope) {
-  const entities = prefilterEntities(text).map((e) => e.id).sort();
+  const extracted = prefilterEntities(text);
+  const entities = extracted.map((e) => e.id).sort();
   const predicate = normalizePredicate(text);
   const stance = detectStance(text);
   const base = { entities, predicate, stance, scope: scope ?? {} };
-  if (predicate === "") base.raw = conceptBag(text);
+  if (predicate === "" || entities.length === 0 || predicateIsTheEntity(text, extracted[0].id, entities.length)) {
+    base.raw = conceptBag(text);
+  }
   return base;
 }
+function predicateIsTheEntity(text, entityId, entityCount) {
+  return entityCount === 1 && normalizePredicate(withoutEntityMentions(text, entityId)) === "";
+}
 function canonicalClaimId(text, scope) {
   const s = claimStructure(text, scope);
   return digest(
@@ -15242,6 +15255,36 @@ var init_history_evidence = __esm({
 });
 
 // ../../packages/shared/src/history-dependencies.ts
+function historyDependencyIdentity(raw) {
+  const compact = compactDependencyIdentity(raw);
+  if (compact !== void 0) return compact;
+  const parsed = HistoryDependencyContextSchema.safeParse(raw);
+  if (!parsed.success || !parsed.data.complete || parsed.data.conflict) return null;
+  if (parsed.data.dependencies.some((d) => !exactHistoryDependencyVersion(d))) return null;
+  return digest(parsed.data.dependencies.map((d) => [d.packageId, d.manifestId, d.side, d.declaredRange, d.resolvedVersion]).sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b))));
+}
+function exactHistoryDependencyVersion(d) {
+  return d.resolvedVersion ?? (/^\d+\.\d+\.\d+(?:-[\w.-]+)?$/.test(d.declaredRange ?? "") ? d.declaredRange : null);
+}
+function compactDependencyIdentity(raw) {
+  if (!raw || typeof raw !== "object" || raw.compact !== true) return void 0;
+  const identity = raw.identity;
+  return typeof identity === "string" ? identity : null;
+}
+function compactHistoryQuality(quality) {
+  const out = { ...quality };
+  const context = quality["dependencyContext"];
+  if (context !== void 0 && compactDependencyIdentity(context) === void 0) {
+    const compact = { schemaVersion: "history-deps-1", compact: true, identity: historyDependencyIdentity(context) };
+    out["dependencyContext"] = compact;
+  }
+  const evidence = quality["reconciliationEvidence"];
+  if (evidence && typeof evidence === "object" && !Array.isArray(evidence)) {
+    const build = evidence["build"];
+    out["reconciliationEvidence"] = build === void 0 ? {} : { build };
+  }
+  return out;
+}
 var version2, HistoryDependencySchema, HistoryDependencyContextSchema;
 var init_history_dependencies = __esm({
   "../../packages/shared/src/history-dependencies.ts"() {
@@ -15726,10 +15769,12 @@ var init_history_quality = __esm({
 });
 
 // ../../packages/shared/src/history-read.ts
+var CLOUD_ATTR_DUPLICATE_KEYS;
 var init_history_read = __esm({
   "../../packages/shared/src/history-read.ts"() {
     "use strict";
     init_history_dependencies();
+    CLOUD_ATTR_DUPLICATE_KEYS = ["attrsJson", "embedding"];
   }
 });
 
@@ -16396,7 +16441,307 @@ function installEditPlaceholderRetirement(db) {
   });
 }
 
+// ../../packages/local-graph/src/cloud-attr-compaction.ts
+init_src2();
+var CLOUD_ATTR_COMPACTION_KEY = "cloud-attr-compaction-1";
+var DUPES = CLOUD_ATTR_DUPLICATE_KEYS.map((k) => `'${k}'`).join(",");
+function compacted(row) {
+  const packed = `json_extract(${row}.attrs_json, '$.attrsJson')`;
+  const nested = `CASE WHEN json_type(${row}.attrs_json, '$.attrsJson') = 'text' AND json_valid(${packed})
+    AND json_type(${packed}) = 'object' THEN ${packed} ELSE '{}' END`;
+  const value = `CASE WHEN type IN ('array','object') THEN json(value) WHEN type IN ('true','false') THEN json(type) ELSE value END`;
+  return `(SELECT json_group_object(key, ${value}) FROM (
+      SELECT key, value, type, min(pri) FROM (
+        SELECT key, value, type, 0 AS pri FROM json_each(${row}.attrs_json)
+        UNION ALL
+        SELECT key, value, type, 1 AS pri FROM json_each(${nested})
+      ) WHERE key NOT IN (${DUPES}) GROUP BY key))`;
+}
+function dirty(row) {
+  const has = CLOUD_ATTR_DUPLICATE_KEYS.map((k) => `json_type(${row}.attrs_json, '$.${k}') IS NOT NULL`).join(" OR ");
+  return `json_extract(${row}.attrs_json, '$.source') = 'cloud' AND (${has})`;
+}
+function installCloudAttrCompaction(db) {
+  if (db.prepare("SELECT value FROM store_meta WHERE key = ?").get(CLOUD_ATTR_COMPACTION_KEY)) return;
+  db.transaction(() => {
+    for (const operation of ["INSERT", "UPDATE"]) {
+      db.exec(`CREATE TRIGGER IF NOT EXISTS cloud_attr_compact_${operation.toLowerCase()}
+        AFTER ${operation} ON nodes WHEN ${dirty("NEW")}
+        BEGIN UPDATE nodes SET attrs_json = ${compacted("nodes")} WHERE id = NEW.id; END;`);
+    }
+    db.exec(`UPDATE nodes SET attrs_json = ${compacted("nodes")} WHERE ${dirty("nodes")}`);
+    db.prepare("INSERT INTO store_meta(key,value) VALUES (?,?)").run(CLOUD_ATTR_COMPACTION_KEY, "installed");
+  });
+}
+
+// ../../packages/local-graph/src/history-attr-slim.ts
+init_src();
+var HISTORY_ATTR_SLIM_KEY = "history-attr-slim-1";
+var SLIM_BATCH = 500;
+function installHistoryAttrSlim(db) {
+  if (db.prepare("SELECT value FROM store_meta WHERE key = ?").get(HISTORY_ATTR_SLIM_KEY)) return;
+  const select = db.prepare(`SELECT rowid AS rid, json_extract(attrs_json, '$.historyQuality') AS q FROM nodes
+    WHERE rowid > ? AND (json_type(attrs_json, '$.historyQuality.dependencyContext.dependencies') IS NOT NULL
+      OR json_type(attrs_json, '$.historyQuality.reconciliationEvidence') = 'object')
+    ORDER BY rowid LIMIT ${SLIM_BATCH}`);
+  const write = db.prepare(`UPDATE nodes SET attrs_json = json_set(attrs_json, '$.historyQuality', json(?)) WHERE rowid = ?`);
+  let after = 0;
+  for (; ; ) {
+    const rows = select.all(after);
+    if (rows.length === 0) break;
+    db.transaction(() => {
+      for (const { rid, q } of rows) {
+        if (!q) continue;
+        let quality;
+        try {
+          quality = JSON.parse(q);
+        } catch {
+          continue;
+        }
+        if (!quality || typeof quality !== "object" || Array.isArray(quality)) continue;
+        const slim = JSON.stringify(compactHistoryQuality(quality));
+        if (slim !== q) write.run(slim, rid);
+      }
+    });
+    after = rows[rows.length - 1].rid;
+  }
+  db.prepare("INSERT INTO store_meta(key,value) VALUES (?,?)").run(HISTORY_ATTR_SLIM_KEY, "done");
+}
+
+// ../../packages/local-graph/src/text-index.ts
+var TEXT_INDEX_KEY = "text-index-trigram-1";
+var TEXT_INDEX_MIN_TERM = 3;
+function installTextIndex(db) {
+  if (db.prepare("SELECT value FROM store_meta WHERE key = ?").get(TEXT_INDEX_KEY)) return;
+  try {
+    db.exec(`CREATE VIRTUAL TABLE temp.fts5_probe USING fts5(x, tokenize='trigram'); DROP TABLE temp.fts5_probe`);
+  } catch {
+    db.prepare("INSERT INTO store_meta(key,value) VALUES (?,?)").run(TEXT_INDEX_KEY, "unavailable");
+    return;
+  }
+  db.transaction(() => {
+    db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS nodes_text
+      USING fts5(description, content='nodes', content_rowid='rowid', tokenize='trigram')`);
+    db.exec(`CREATE TRIGGER IF NOT EXISTS nodes_text_insert AFTER INSERT ON nodes WHEN NEW.valid_to IS NULL
+      BEGIN INSERT INTO nodes_text(rowid, description) VALUES (NEW.rowid, NEW.description); END;`);
+    db.exec(`CREATE TRIGGER IF NOT EXISTS nodes_text_update_out AFTER UPDATE OF description, valid_to ON nodes
+      WHEN OLD.valid_to IS NULL
+      BEGIN INSERT INTO nodes_text(nodes_text, rowid, description) VALUES ('delete', OLD.rowid, OLD.description); END;`);
+    db.exec(`CREATE TRIGGER IF NOT EXISTS nodes_text_update_in AFTER UPDATE OF description, valid_to ON nodes
+      WHEN NEW.valid_to IS NULL
+      BEGIN INSERT INTO nodes_text(rowid, description) VALUES (NEW.rowid, NEW.description); END;`);
+    db.exec(`CREATE TRIGGER IF NOT EXISTS nodes_text_delete AFTER DELETE ON nodes WHEN OLD.valid_to IS NULL
+      BEGIN INSERT INTO nodes_text(nodes_text, rowid, description) VALUES ('delete', OLD.rowid, OLD.description); END;`);
+    db.exec(`INSERT INTO nodes_text(rowid, description) SELECT rowid, description FROM nodes WHERE valid_to IS NULL`);
+    db.prepare("INSERT INTO store_meta(key,value) VALUES (?,?)").run(TEXT_INDEX_KEY, "installed");
+  });
+}
+function textIndexReady(db) {
+  return db.prepare("SELECT value FROM store_meta WHERE key = ?").get(TEXT_INDEX_KEY)?.["value"] === "installed";
+}
+
+// ../../packages/math/src/constants.ts
+var NEMORI_DEDUP_COSINE = 0.88;
+
+// ../../packages/math/src/triage.ts
+var TRIAGE_GLOBAL_BUCKET = "*";
+function triageContextBuckets(ctx) {
+  const out = [];
+  for (const s of ctx.stack ?? []) {
+    const t = s.trim().toLowerCase();
+    if (t) out.push(`stack:${t}`);
+  }
+  const domains = Array.isArray(ctx.domain) ? ctx.domain : typeof ctx.domain === "string" ? [ctx.domain] : [];
+  for (const d of domains) {
+    const t = d.trim().toLowerCase();
+    if (t) out.push(`domain:${t}`);
+  }
+  return out;
+}
+
+// ../../packages/math/src/relevance.ts
+function pageRankScale(ranks) {
+  const positive = [...ranks].filter((r) => Number.isFinite(r) && r > 0).sort((a, b) => a - b);
+  return positive.length ? Math.max(1e-9, positive[Math.floor((positive.length - 1) * 0.95)]) : 1;
+}
+
+// ../../packages/math/src/leiden.ts
+function buildGraph(nodeIds, adj) {
+  const nbr = /* @__PURE__ */ new Map();
+  const deg = /* @__PURE__ */ new Map();
+  const present = new Set(nodeIds);
+  for (const id of nodeIds) {
+    nbr.set(id, /* @__PURE__ */ new Map());
+    deg.set(id, 0);
+  }
+  let m2 = 0;
+  for (const id of nodeIds) {
+    for (const { to, weight } of adj.get(id) ?? []) {
+      if (!present.has(to)) continue;
+      const row = nbr.get(id);
+      row.set(to, (row.get(to) ?? 0) + weight);
+      deg.set(id, (deg.get(id) ?? 0) + weight);
+      m2 += weight;
+    }
+  }
+  return { nbr, deg, m2 };
+}
+function localMoving(nodeIds, g) {
+  const community = new Map(nodeIds.map((n) => [n, n]));
+  const comTot = new Map(nodeIds.map((n) => [n, g.deg.get(n) ?? 0]));
+  const order = [...nodeIds].sort();
+  const m2 = g.m2 > 0 ? g.m2 : 1;
+  let improved = true;
+  let iter = 0;
+  while (improved && iter < 100) {
+    improved = false;
+    iter++;
+    for (const node of order) {
+      const ci = community.get(node);
+      const ki = g.deg.get(node) ?? 0;
+      comTot.set(ci, (comTot.get(ci) ?? 0) - ki);
+      const wToComm = /* @__PURE__ */ new Map();
+      for (const [nb, w] of g.nbr.get(node) ?? []) {
+        if (nb === node) continue;
+        const c = community.get(nb);
+        wToComm.set(c, (wToComm.get(c) ?? 0) + w);
+      }
+      let bestC = ci;
+      let bestGain = (wToComm.get(ci) ?? 0) - (comTot.get(ci) ?? 0) * ki / m2;
+      for (const [c, kiIn] of [...wToComm.entries()].sort(
+        (a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0
+      )) {
+        const gain = kiIn - (comTot.get(c) ?? 0) * ki / m2;
+        if (gain > bestGain) {
+          bestGain = gain;
+          bestC = c;
+        }
+      }
+      community.set(node, bestC);
+      comTot.set(bestC, (comTot.get(bestC) ?? 0) + ki);
+      if (bestC !== ci) improved = true;
+    }
+  }
+  return community;
+}
+function refineConnectivity(community, g) {
+  const members = /* @__PURE__ */ new Map();
+  for (const [id, c] of community) {
+    const l = members.get(c) ?? [];
+    l.push(id);
+    members.set(c, l);
+  }
+  const refined = /* @__PURE__ */ new Map();
+  for (const [, group] of members) {
+    const inGroup = new Set(group);
+    const seen = /* @__PURE__ */ new Set();
+    for (const start of [...group].sort()) {
+      if (seen.has(start)) continue;
+      const comp = [];
+      const stack = [start];
+      seen.add(start);
+      while (stack.length) {
+        const cur = stack.pop();
+        comp.push(cur);
+        for (const [nb] of g.nbr.get(cur) ?? []) {
+          if (inGroup.has(nb) && !seen.has(nb)) {
+            seen.add(nb);
+            stack.push(nb);
+          }
+        }
+      }
+      const anchor = [...comp].sort()[0];
+      for (const id of comp) refined.set(id, anchor);
+    }
+  }
+  return refined;
+}
+function normalize(assignment) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [id, c] of assignment) {
+    const l = groups.get(c) ?? [];
+    l.push(id);
+    groups.set(c, l);
+  }
+  const community = /* @__PURE__ */ new Map();
+  for (const grp of groups.values()) {
+    const anchor = [...grp].sort()[0];
+    const cid = `community_${anchor}`;
+    for (const m of grp) community.set(m, cid);
+  }
+  return { community, count: groups.size, iterations: 1 };
+}
+function causalComponents(nodeIds, pairs) {
+  const parent = new Map(nodeIds.map((n) => [n, n]));
+  const find = (x) => {
+    let r = x;
+    while (parent.get(r) !== r) r = parent.get(r);
+    let c = x;
+    while (parent.get(c) !== r) {
+      const next = parent.get(c);
+      parent.set(c, r);
+      c = next;
+    }
+    return r;
+  };
+  for (const [a, b] of pairs) {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent.set(ra < rb ? rb : ra, ra < rb ? ra : rb);
+  }
+  return find;
+}
+function detectCommunitiesLeiden(input, opts = {}) {
+  const idSet = new Set(input.nodeIds);
+  const protect = [...opts.protect ?? []].filter(
+    ([a, b]) => a !== b && idSet.has(a) && idSet.has(b)
+  );
+  if (protect.length === 0) {
+    const g = buildGraph(input.nodeIds, input.adj);
+    return normalize(refineConnectivity(localMoving(input.nodeIds, g), g));
+  }
+  const rep = causalComponents(input.nodeIds, protect);
+  const superIds = [...new Set(input.nodeIds.map(rep))];
+  const superAdj = /* @__PURE__ */ new Map();
+  const acc = /* @__PURE__ */ new Map();
+  for (const id of input.nodeIds) {
+    const ra = rep(id);
+    for (const { to, weight } of input.adj.get(id) ?? []) {
+      if (!idSet.has(to)) continue;
+      const rb = rep(to);
+      if (ra === rb) continue;
+      const row = acc.get(ra) ?? /* @__PURE__ */ new Map();
+      row.set(rb, (row.get(rb) ?? 0) + weight);
+      acc.set(ra, row);
+    }
+  }
+  for (const [a, row] of acc) superAdj.set(a, [...row].map(([to, weight]) => ({ to, weight })));
+  const sg = buildGraph(superIds, superAdj);
+  const superComm = refineConnectivity(localMoving(superIds, sg), sg);
+  const assignment = /* @__PURE__ */ new Map();
+  for (const id of input.nodeIds) assignment.set(id, superComm.get(rep(id)) ?? rep(id));
+  return normalize(assignment);
+}
+
+// ../../packages/math/src/void-demand.ts
+var DEMAND_HOT = Math.log1p(10);
+var DEMAND_WARM = Math.log1p(5);
+
 // ../../packages/local-graph/src/store.ts
+var PAGE_RANK_SCALE_KEY = "pageRankScale.p95.v1";
+var TEXT_SEARCH_COLUMNS = `id, label, description, page_rank,
+  json_object('test', json(CASE WHEN json_type(attrs_json, '$.test') = 'true' THEN 'true' ELSE 'false' END),
+    'relPath', json_extract(attrs_json, '$.relPath'),
+    'resolutionSuspect', json(CASE WHEN json_type(attrs_json, '$.resolutionSuspect') = 'true' THEN 'true' ELSE 'false' END),
+    'resolvedAt', json_extract(attrs_json, '$.resolvedAt'),
+    'refutedAt', json_extract(attrs_json, '$.refutedAt'),
+    'refuteReasons', json_extract(attrs_json, '$.refuteReasons'),
+    'reopenedFrom', json_extract(attrs_json, '$.reopenedFrom'),
+    'resolvedAs', json_extract(attrs_json, '$.resolvedAs')) AS search_attrs`;
+function textSearchNode(row) {
+  const attrs = JSON.parse(row.search_attrs);
+  return { id: row.id, label: row.label, description: row.description, pageRank: row.page_rank, attrs };
+}
 var LOCAL_RULE_OVERRIDES = {
   ANCHORED_AT: {
     from: EDGE_RULES["ANCHORED_AT"]?.from,
@@ -16540,6 +16885,9 @@ CREATE INDEX IF NOT EXISTS edges_session_evidence ON edges(id) WHERE ${SESSION_E
 DROP INDEX IF EXISTS nodes_live_fingerprint;
 DROP INDEX IF EXISTS nodes_instance_fingerprint;
 CREATE INDEX IF NOT EXISTS nodes_instance_fingerprint_v2 ON nodes(label, last_updated_at, last_reinforced_at_seq, created_at_seq) WHERE valid_to IS NULL AND label IN ('Problem','Vulnerability','Solution','RootCause');
+-- Calibrate rank from a covering scalar index; the global page-rank index
+-- requires a table lookup per node to exclude frozen versions.
+CREATE INDEX IF NOT EXISTS nodes_live_page_rank ON nodes(valid_to, page_rank);
 CREATE INDEX IF NOT EXISTS nodes_logical ON nodes(logical_id, version);
 CREATE INDEX IF NOT EXISTS edges_live ON edges(valid_to);
 -- Expression index on the per-node relPath (stored in attrs_json) so the
@@ -16552,6 +16900,16 @@ CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) W
 -- Problems by the file their anchor hint names: the harvest upgrades hints for
 -- every edited file of every turn, and a scan parses every Problem's attrs.
 CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path ON nodes(json_extract(attrs_json, '$.anchorHint.path')) WHERE valid_to IS NULL;
+-- Problems by the command / checker / file that opened them. The generalizer
+-- looked these up per shell or tool EVENT by hydrating every Problem: ~12s of
+-- every minute of daemon main-thread time on a 3.4k-Problem store (2026-10-05).
+CREATE INDEX IF NOT EXISTS nodes_command_signature ON nodes(json_extract(attrs_json, '$.commandSignature')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_diag_command ON nodes(json_extract(attrs_json, '$.diagCommand')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_lsp_rel_path ON nodes(json_extract(attrs_json, '$.lspRelPath')) WHERE valid_to IS NULL;
+-- Local nodes by the cloud twin their upload receipt recorded. Every burst /
+-- search fusion folds the Network copy of the caller's own knowledge back onto
+-- the local node; unindexed, the reverse lookup was a ~300ms attrs scan per call.
+CREATE INDEX IF NOT EXISTS nodes_cloud_node_id ON nodes(json_extract(attrs_json, '$.cloudNodeId')) WHERE valid_to IS NULL;
 -- Nodes still waiting on a root-cause ask. The MCP server checks this on EVERY
 -- tool response (the enrichment piggyback), so it must not parse every
 -- Solution's and Problem's attrs per call. Not partial: the Problem pull reads
@@ -16638,6 +16996,7 @@ var SqliteGraphStore = class {
    *  ALL upserts incl. code reindex) — this counter is the knowledge-arrival axis
    *  Δseq is measured over, so code reindex churn must NOT advance it. */
   ingestSeq = 0;
+  initialPageRankScale;
   constructor(opts) {
     this.db = openDatabase(opts.path);
     this.db.exec(SCHEMA_SQL);
@@ -16654,6 +17013,9 @@ var SqliteGraphStore = class {
     this.db.exec(TEMPORAL_INDEX_SQL);
     installHistoryCacheFloor(this.db);
     installEditPlaceholderRetirement(this.db);
+    installCloudAttrCompaction(this.db);
+    installHistoryAttrSlim(this.db);
+    installTextIndex(this.db);
     if (!this.db.prepare("SELECT value FROM store_meta WHERE key = ?").get(SESSION_REPAIR_KEY)) {
       this.db.transaction(() => {
         this.repairSessionAliases();
@@ -16705,6 +17067,12 @@ var SqliteGraphStore = class {
       setPageRank: this.db.prepare("UPDATE nodes SET page_rank = :v WHERE id = :id"),
       setLandmark: this.db.prepare("UPDATE nodes SET is_landmark = :v WHERE id = :id"),
       setCommunity: this.db.prepare("UPDATE nodes SET community = :v WHERE id = :id"),
+      setLocalCommunity: this.db.prepare(`
+        UPDATE nodes SET
+          attrs_json = CASE WHEN :v IS NULL THEN json_remove(attrs_json, '$.localCommunity')
+                            ELSE json_set(attrs_json, '$.localCommunity', :v) END,
+          community = CASE WHEN :col = 1 THEN :v ELSE community END
+        WHERE id = :id`),
       updateNode: this.db.prepare(`
         UPDATE nodes SET
           description = COALESCE(:description, description),
@@ -17025,6 +17393,36 @@ var SqliteGraphStore = class {
   setLandmark(id, isLandmark) {
     this.stmts.setLandmark.run({ id, v: isLandmark ? 1 : 0 });
   }
+  setLocalCommunity(id, community, column) {
+    this.stmts.setLocalCommunity.run({ id, v: community, col: column ? 1 : 0 });
+  }
+  fieldStmts = /* @__PURE__ */ new Map();
+  findNodeFieldsByLabel(label, attrKeys) {
+    for (const k of attrKeys) if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(k)) throw new Error(`findNodeFieldsByLabel: bad attr key ${k}`);
+    const cacheKey = attrKeys.join(",");
+    let stmt = this.fieldStmts.get(cacheKey);
+    if (!stmt) {
+      const cols = attrKeys.map((k, i) => `, json_extract(attrs_json, '$.${k}') AS a${i}`).join("");
+      stmt = this.db.prepare(
+        `SELECT id, description, community, extraction_confidence${cols} FROM nodes WHERE label = ? AND valid_to IS NULL`
+      );
+      this.fieldStmts.set(cacheKey, stmt);
+    }
+    return stmt.all(label).map((r) => {
+      const attrs = {};
+      attrKeys.forEach((k, i) => {
+        const v = r[`a${i}`];
+        if (v !== null && v !== void 0) attrs[k] = v;
+      });
+      return {
+        id: r["id"],
+        description: r["description"] ?? "",
+        community: r["community"] ?? null,
+        extractionConfidence: r["extraction_confidence"],
+        attrs
+      };
+    });
+  }
   setCommunity(id, community) {
     this.stmts.setCommunity.run({ id, v: community });
   }
@@ -17151,6 +17549,19 @@ var SqliteGraphStore = class {
    *  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). */
+  findNodeStampsByLabel(label, attrKey) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(attrKey)) throw new Error(`findNodeStampsByLabel: bad attr key ${attrKey}`);
+    const rows = this.db.prepare(
+      `SELECT id, created_at, created_at_seq, json_type(attrs_json, '$.${attrKey}') IS NOT NULL AS has
+           FROM nodes WHERE label = ? AND valid_to IS NULL`
+    ).all(label);
+    return rows.map((r) => ({
+      id: r.id,
+      createdAt: r.created_at,
+      ...r.created_at_seq != null ? { createdAtSeq: r.created_at_seq } : {},
+      has: r.has === 1
+    }));
+  }
   findNodeAttrsByLabel(label) {
     const rows = this.stmts.attrsByLabel.all(label);
     return rows.map((r) => ({
@@ -17257,6 +17668,60 @@ var SqliteGraphStore = class {
     ).all(...terms.map((t) => `%${t}%`), Math.max(1, limit));
     return rows.map((r) => ({ node: rowToNode(r), matched: Number(r.matched) }));
   }
+  searchTextCandidates(terms) {
+    if (terms.length === 0) return [];
+    const indexed = terms.filter((t) => t.length >= TEXT_INDEX_MIN_TERM);
+    if (indexed.length > 0 && textIndexReady(this.db)) {
+      const short = terms.filter((t) => t.length < TEXT_INDEX_MIN_TERM).map((t) => t.toLowerCase());
+      const rows2 = this.db.prepare(`WITH hits AS MATERIALIZED (
+        SELECT t.rowid AS rid, COUNT(*) AS matched FROM json_each(:terms) q, nodes_text t
+        WHERE t.description LIKE '%' || q.value || '%' GROUP BY t.rowid
+      ) SELECT ${TEXT_SEARCH_COLUMNS}, hits.matched FROM hits JOIN nodes ON nodes.rowid = hits.rid
+        WHERE nodes.valid_to IS NULL ORDER BY page_rank DESC, last_updated_at DESC`).all({ terms: JSON.stringify(indexed) });
+      return rows2.map((row) => {
+        const text = row.description.toLowerCase();
+        const extra = short.filter((t) => text.includes(t)).length;
+        return { node: textSearchNode(row), matched: row.matched + extra };
+      });
+    }
+    const rows = this.db.prepare(`WITH matches AS MATERIALIZED (
+      SELECT n.id, COUNT(*) AS matched FROM nodes n INDEXED BY nodes_live_description, json_each(:terms) t
+      WHERE n.valid_to IS NULL AND n.description LIKE '%' || t.value || '%'
+      GROUP BY n.id
+    ) SELECT ${TEXT_SEARCH_COLUMNS}, matches.matched FROM nodes
+      JOIN matches USING (id) ORDER BY page_rank DESC, last_updated_at DESC`).all({ terms: JSON.stringify(terms) });
+    return rows.map((row) => ({ node: textSearchNode(row), matched: row.matched }));
+  }
+  commentAnchors(commentIds) {
+    const out = /* @__PURE__ */ new Map();
+    if (commentIds.length === 0) return out;
+    const rows = this.db.prepare(`WITH a AS MATERIALIZED (
+      SELECT q.value AS cid, COALESCE(
+        (SELECT to_id FROM edges WHERE from_id = q.value AND type IN ('EXPLAINS', 'ANNOTATES') AND valid_to IS NULL LIMIT 1),
+        (SELECT from_id FROM edges WHERE to_id = q.value AND type = 'DOCUMENTED_BY' AND valid_to IS NULL LIMIT 1)
+      ) AS aid FROM json_each(:ids) q
+    ) SELECT a.cid AS cid, ${TEXT_SEARCH_COLUMNS} FROM a JOIN nodes ON nodes.id = a.aid AND nodes.valid_to IS NULL`).all({ ids: JSON.stringify(commentIds) });
+    for (const row of rows) out.set(row.cid, textSearchNode(row));
+    return out;
+  }
+  getTextSearchNode(id) {
+    const row = this.db.prepare(`SELECT ${TEXT_SEARCH_COLUMNS} FROM nodes WHERE id = ? AND valid_to IS NULL`).get(id);
+    return row ? textSearchNode(row) : null;
+  }
+  readPageRankScale() {
+    const rows = this.db.prepare("SELECT page_rank FROM nodes WHERE valid_to IS NULL AND page_rank > 0").all();
+    return pageRankScale(rows.map((row) => row.page_rank));
+  }
+  pageRankScale() {
+    const value = Number(this.getMeta(PAGE_RANK_SCALE_KEY));
+    if (Number.isFinite(value) && value > 0) return value;
+    return this.initialPageRankScale ??= this.readPageRankScale();
+  }
+  refreshPageRankScale() {
+    const scale = this.readPageRankScale();
+    this.setMeta(PAGE_RANK_SCALE_KEY, String(scale));
+    return scale;
+  }
   typedEdgeStmt(sql) {
     let stmt = this.typedEdgeStmts.get(sql);
     if (!stmt) {
@@ -17491,6 +17956,19 @@ var SqliteGraphStore = class {
     ).get(attr, `%${marker}%`, limit);
     return { count: Number(r.count), total: Number(r.total) };
   }
+  liveNodeIdsByCloudNodeId(cloudIds) {
+    const out = /* @__PURE__ */ new Map();
+    const CHUNK = 900;
+    for (let i = 0; i < cloudIds.length; i += CHUNK) {
+      const slice = cloudIds.slice(i, i + CHUNK);
+      if (slice.length === 0) continue;
+      const rows = this.db.prepare(
+        `SELECT id, json_extract(attrs_json, '$.cloudNodeId') AS cloud FROM nodes INDEXED BY nodes_cloud_node_id WHERE json_extract(attrs_json, '$.cloudNodeId') IN (${slice.map(() => "?").join(",")}) AND valid_to IS NULL ORDER BY id`
+      ).all(...slice);
+      for (const r of rows) out.set(r.cloud, [...out.get(r.cloud) ?? [], r.id]);
+    }
+    return out;
+  }
   liveNodeIds(ids) {
     const live = /* @__PURE__ */ new Set();
     const CHUNK = 900;
@@ -17552,7 +18030,10 @@ var SqliteGraphStore = class {
     if (relPaths.length === 0) return [];
     const placeholders = relPaths.map(() => "?").join(",");
     const rows = this.db.prepare(
-      `SELECT * FROM nodes WHERE valid_to IS NULL AND json_extract(attrs_json, '$.relPath') IN (${placeholders})`
+      // INDEXED BY: unforced, the planner took nodes_live_page_rank and
+      // json-parsed every live row — 11–25s per reindexed file pair on the
+      // live store vs 7ms here (2026-10-08).
+      `SELECT * FROM nodes INDEXED BY nodes_relpath WHERE valid_to IS NULL AND json_extract(attrs_json, '$.relPath') IN (${placeholders})`
     ).all(...relPaths);
     return rows.map(rowToNode);
   }
@@ -17802,183 +18283,6 @@ function percolate(l1, l2, opts) {
 init_src();
 init_src2();
 
-// ../../packages/math/src/constants.ts
-var NEMORI_DEDUP_COSINE = 0.88;
-
-// ../../packages/math/src/triage.ts
-var TRIAGE_GLOBAL_BUCKET = "*";
-function triageContextBuckets(ctx) {
-  const out = [];
-  for (const s of ctx.stack ?? []) {
-    const t = s.trim().toLowerCase();
-    if (t) out.push(`stack:${t}`);
-  }
-  const domains = Array.isArray(ctx.domain) ? ctx.domain : typeof ctx.domain === "string" ? [ctx.domain] : [];
-  for (const d of domains) {
-    const t = d.trim().toLowerCase();
-    if (t) out.push(`domain:${t}`);
-  }
-  return out;
-}
-
-// ../../packages/math/src/leiden.ts
-function buildGraph(nodeIds, adj) {
-  const nbr = /* @__PURE__ */ new Map();
-  const deg = /* @__PURE__ */ new Map();
-  const present = new Set(nodeIds);
-  for (const id of nodeIds) {
-    nbr.set(id, /* @__PURE__ */ new Map());
-    deg.set(id, 0);
-  }
-  let m2 = 0;
-  for (const id of nodeIds) {
-    for (const { to, weight } of adj.get(id) ?? []) {
-      if (!present.has(to)) continue;
-      const row = nbr.get(id);
-      row.set(to, (row.get(to) ?? 0) + weight);
-      deg.set(id, (deg.get(id) ?? 0) + weight);
-      m2 += weight;
-    }
-  }
-  return { nbr, deg, m2 };
-}
-function localMoving(nodeIds, g) {
-  const community = new Map(nodeIds.map((n) => [n, n]));
-  const comTot = new Map(nodeIds.map((n) => [n, g.deg.get(n) ?? 0]));
-  const order = [...nodeIds].sort();
-  const m2 = g.m2 > 0 ? g.m2 : 1;
-  let improved = true;
-  let iter = 0;
-  while (improved && iter < 100) {
-    improved = false;
-    iter++;
-    for (const node of order) {
-      const ci = community.get(node);
-      const ki = g.deg.get(node) ?? 0;
-      comTot.set(ci, (comTot.get(ci) ?? 0) - ki);
-      const wToComm = /* @__PURE__ */ new Map();
-      for (const [nb, w] of g.nbr.get(node) ?? []) {
-        if (nb === node) continue;
-        const c = community.get(nb);
-        wToComm.set(c, (wToComm.get(c) ?? 0) + w);
-      }
-      let bestC = ci;
-      let bestGain = (wToComm.get(ci) ?? 0) - (comTot.get(ci) ?? 0) * ki / m2;
-      for (const [c, kiIn] of [...wToComm.entries()].sort(
-        (a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0
-      )) {
-        const gain = kiIn - (comTot.get(c) ?? 0) * ki / m2;
-        if (gain > bestGain) {
-          bestGain = gain;
-          bestC = c;
-        }
-      }
-      community.set(node, bestC);
-      comTot.set(bestC, (comTot.get(bestC) ?? 0) + ki);
-      if (bestC !== ci) improved = true;
-    }
-  }
-  return community;
-}
-function refineConnectivity(community, g) {
-  const members = /* @__PURE__ */ new Map();
-  for (const [id, c] of community) {
-    const l = members.get(c) ?? [];
-    l.push(id);
-    members.set(c, l);
-  }
-  const refined = /* @__PURE__ */ new Map();
-  for (const [, group] of members) {
-    const inGroup = new Set(group);
-    const seen = /* @__PURE__ */ new Set();
-    for (const start of [...group].sort()) {
-      if (seen.has(start)) continue;
-      const comp = [];
-      const stack = [start];
-      seen.add(start);
-      while (stack.length) {
-        const cur = stack.pop();
-        comp.push(cur);
-        for (const [nb] of g.nbr.get(cur) ?? []) {
-          if (inGroup.has(nb) && !seen.has(nb)) {
-            seen.add(nb);
-            stack.push(nb);
-          }
-        }
-      }
-      const anchor = [...comp].sort()[0];
-      for (const id of comp) refined.set(id, anchor);
-    }
-  }
-  return refined;
-}
-function normalize(assignment) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const [id, c] of assignment) {
-    const l = groups.get(c) ?? [];
-    l.push(id);
-    groups.set(c, l);
-  }
-  const community = /* @__PURE__ */ new Map();
-  for (const grp of groups.values()) {
-    const anchor = [...grp].sort()[0];
-    const cid = `community_${anchor}`;
-    for (const m of grp) community.set(m, cid);
-  }
-  return { community, count: groups.size, iterations: 1 };
-}
-function causalComponents(nodeIds, pairs) {
-  const parent = new Map(nodeIds.map((n) => [n, n]));
-  const find = (x) => {
-    let r = x;
-    while (parent.get(r) !== r) r = parent.get(r);
-    let c = x;
-    while (parent.get(c) !== r) {
-      const next = parent.get(c);
-      parent.set(c, r);
-      c = next;
-    }
-    return r;
-  };
-  for (const [a, b] of pairs) {
-    const ra = find(a);
-    const rb = find(b);
-    if (ra !== rb) parent.set(ra < rb ? rb : ra, ra < rb ? ra : rb);
-  }
-  return find;
-}
-function detectCommunitiesLeiden(input, opts = {}) {
-  const idSet = new Set(input.nodeIds);
-  const protect = [...opts.protect ?? []].filter(
-    ([a, b]) => a !== b && idSet.has(a) && idSet.has(b)
-  );
-  if (protect.length === 0) {
-    const g = buildGraph(input.nodeIds, input.adj);
-    return normalize(refineConnectivity(localMoving(input.nodeIds, g), g));
-  }
-  const rep = causalComponents(input.nodeIds, protect);
-  const superIds = [...new Set(input.nodeIds.map(rep))];
-  const superAdj = /* @__PURE__ */ new Map();
-  const acc = /* @__PURE__ */ new Map();
-  for (const id of input.nodeIds) {
-    const ra = rep(id);
-    for (const { to, weight } of input.adj.get(id) ?? []) {
-      if (!idSet.has(to)) continue;
-      const rb = rep(to);
-      if (ra === rb) continue;
-      const row = acc.get(ra) ?? /* @__PURE__ */ new Map();
-      row.set(rb, (row.get(rb) ?? 0) + weight);
-      acc.set(ra, row);
-    }
-  }
-  for (const [a, row] of acc) superAdj.set(a, [...row].map(([to, weight]) => ({ to, weight })));
-  const sg = buildGraph(superIds, superAdj);
-  const superComm = refineConnectivity(localMoving(superIds, sg), sg);
-  const assignment = /* @__PURE__ */ new Map();
-  for (const id of input.nodeIds) assignment.set(id, superComm.get(rep(id)) ?? rep(id));
-  return normalize(assignment);
-}
-
 // ../../packages/local-graph/src/triage.ts
 init_src();
 init_src();
@@ -19368,7 +19672,7 @@ var DOC_COMMENT_KINDS = /* @__PURE__ */ new Set(["docstring", "explanation"]);
 var MAX_DOC_CHARS = 600;
 function buildDocIndex(store) {
   const byName = /* @__PURE__ */ new Map();
-  for (const c of store.findNodesByLabel("Comment")) {
+  for (const c of store.findNodeFieldsByLabel("Comment", ["attachedTo", "kind", "text"])) {
     const name = c.attrs["attachedTo"];
     const kind = c.attrs["kind"];
     if (typeof name !== "string" || !name) continue;
@@ -19384,7 +19688,7 @@ function buildSymbolLexicon(store) {
   const docs = buildDocIndex(store);
   const candidates = [];
   for (const [label, kind] of SYMBOL_LABELS) {
-    for (const n of store.findNodesByLabel(label)) {
+    for (const n of store.findNodeFieldsByLabel(label, ["qname"])) {
       const qname = String(n.attrs["qname"] ?? "");
       const doc = (n.description ? docs.get(n.description) : void 0) ?? (qname ? docs.get(qname) : void 0);
       for (const name of [n.description, qname]) {
@@ -19490,7 +19794,7 @@ function buildFileLexicon(store) {
   const basenameCount = /* @__PURE__ */ new Map();
   const stemRelPaths = /* @__PURE__ */ new Map();
   const entries = [];
-  for (const n of store.findNodesByLabel("File")) {
+  for (const n of store.findNodeFieldsByLabel("File", ["relPath"])) {
     const relPath = typeof n.attrs["relPath"] === "string" && n.attrs["relPath"].length > 0 ? n.attrs["relPath"] : n.description;
     if (!relPath) continue;
     const basename = relPath.split("/").pop();
@@ -19812,9 +20116,7 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
     collapsedEdges: 0
   };
   const sharedCauses = /* @__PURE__ */ new Map();
-  const causalQueue = store.findNodesByLabel("Problem").filter(
-    (n) => n.attrs["source"] !== "cloud" && n.attrs["resolvedAs"] !== PROBLEM_RESOLUTION.FALSE_POSITIVE && !ignored(n.description)
-  ).map((n) => n.id);
+  const causalQueue = store.findNodeFieldsByLabel("Problem", ["source", "resolvedAs"]).filter((r) => r.attrs["source"] !== "cloud" && r.attrs["resolvedAs"] !== PROBLEM_RESOLUTION.FALSE_POSITIVE).map((r) => r.id).filter((id) => ignorePatterns.length === 0 || !ignored(store.getNode(id)?.description ?? ""));
   const causalSeen = new Set(causalQueue);
   for (let i = 0; i < causalQueue.length; i++) {
     const id = causalQueue[i];
@@ -19830,7 +20132,20 @@ function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [],
   for (const label of INSTANCE_LABELS) {
     const ref = [];
     includedByLabel.set(label, ref);
-    const population = label === "RootCause" && opts.sharedStore ? [...store.findNodesByLabel(label), ...sharedCauses.values()] : store.findNodesByLabel(label);
+    const local = [];
+    for (const row of store.findNodeFieldsByLabel(label, ["source", "privateFinding"])) {
+      if (row.attrs["source"] !== "cloud") {
+        const n = store.getNode(row.id);
+        if (n) local.push(n);
+        continue;
+      }
+      if (seen.has(row.id) || walked.has(row.id)) continue;
+      walked.add(row.id);
+      composition.candidates++;
+      if ((row.attrs["privateFinding"] || label === "Vulnerability") && !opts.project) composition.privateTargetMissing++;
+      else composition.cloudSourced++;
+    }
+    const population = label === "RootCause" && opts.sharedStore ? [...local, ...sharedCauses.values()] : local;
     for (const n of population) {
       if (seen.has(n.id)) continue;
       if (walked.has(n.id)) continue;