@inerrata-corporation/errata 2.0.21-dev.3745 → 2.0.21-dev.3763

package/pass-worker.mjs

@@ -16146,10 +16146,12 @@ function historyReadPolicy(node, options = {}) {
     notice: `History-derived${at}; source ${String(source)}; applicability ${current ? String(applicability) : "unknown at this checkout"}; ${environmentKnown ? "dependency context checked" : "dependency applicability unverified"}; ${independentlyValidated ? "separate validation recorded" : "not independently validated"}.`
   };
 }
+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"];
   }
 });
 
@@ -25425,7 +25427,474 @@ 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/math/src/pagerank.ts
+function pagerank(input) {
+  const damping = input.damping ?? 0.85;
+  const tol = input.tolerance ?? 1e-6;
+  const maxIter = input.maxIterations ?? 100;
+  const ids = input.nodeIds;
+  const n = ids.length;
+  if (n === 0) {
+    return { scores: /* @__PURE__ */ new Map(), iterations: 0, converged: true, danglingRank: 0 };
+  }
+  const index = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < n; i2++) index.set(ids[i2], i2);
+  const outSum = new Float64Array(n);
+  const dangling = new Uint8Array(n).fill(1);
+  const rowLen = new Int32Array(n);
+  let edgeCount = 0;
+  for (const [from, edges] of input.out) {
+    const fi = index.get(from);
+    if (fi === void 0) continue;
+    let sum = 0;
+    let inSet = 0;
+    for (const e of edges) {
+      sum += e.weight;
+      if (index.has(e.to)) inSet++;
+    }
+    if (sum > 0) {
+      outSum[fi] = sum;
+      dangling[fi] = 0;
+    }
+    rowLen[fi] = inSet;
+    edgeCount += inSet;
+  }
+  const rowStart = new Int32Array(n + 1);
+  for (let i2 = 0; i2 < n; i2++) rowStart[i2 + 1] = rowStart[i2] + rowLen[i2];
+  const colIdx = new Int32Array(edgeCount);
+  const colW = new Float64Array(edgeCount);
+  const cursor = rowStart.slice(0, n);
+  for (const [from, edges] of input.out) {
+    const fi = index.get(from);
+    if (fi === void 0) continue;
+    for (const e of edges) {
+      const ti = index.get(e.to);
+      if (ti === void 0) continue;
+      const c = cursor[fi];
+      cursor[fi] = c + 1;
+      colIdx[c] = ti;
+      colW[c] = e.weight;
+    }
+  }
+  let score2 = new Float64Array(n).fill(1 / n);
+  let next = new Float64Array(n);
+  const base = (1 - damping) / n;
+  let iter = 0;
+  let converged = false;
+  for (; iter < maxIter; iter++) {
+    next.fill(base);
+    let danglingMass = 0;
+    for (let i2 = 0; i2 < n; i2++) if (dangling[i2]) danglingMass += score2[i2];
+    for (let i2 = 0; i2 < n; i2++) {
+      if (dangling[i2]) continue;
+      const f = damping * score2[i2] / outSum[i2];
+      const end = rowStart[i2 + 1];
+      for (let c = rowStart[i2]; c < end; c++) next[colIdx[c]] += f * colW[c];
+    }
+    if (danglingMass > 0) {
+      const share = damping * danglingMass / n;
+      for (let i2 = 0; i2 < n; i2++) next[i2] += share;
+    }
+    let diff = 0;
+    for (let i2 = 0; i2 < n; i2++) diff += Math.abs(next[i2] - score2[i2]);
+    const tmp = score2;
+    score2 = next;
+    next = tmp;
+    if (diff < tol) {
+      iter++;
+      converged = true;
+      break;
+    }
+  }
+  const scores = /* @__PURE__ */ new Map();
+  let danglingRank = 0;
+  for (let i2 = 0; i2 < n; i2++) {
+    scores.set(ids[i2], score2[i2]);
+    if (dangling[i2]) danglingRank += score2[i2];
+  }
+  return { scores, iterations: iter, converged, danglingRank };
+}
+function markLandmarks(scores, percentile = 0.1, filter) {
+  const entries = [...scores.entries()];
+  if (filter) {
+    for (let i2 = entries.length - 1; i2 >= 0; i2--) {
+      if (!filter(entries[i2][0])) entries.splice(i2, 1);
+    }
+  }
+  if (entries.length === 0) return /* @__PURE__ */ new Set();
+  entries.sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
+  const cutoff = Math.max(1, Math.floor(entries.length * percentile));
+  const out2 = /* @__PURE__ */ new Set();
+  for (let i2 = 0; i2 < cutoff; i2++) {
+    out2.add(entries[i2][0]);
+  }
+  return out2;
+}
+
+// ../../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 start2 of [...group].sort()) {
+      if (seen.has(start2)) continue;
+      const comp = [];
+      const stack = [start2];
+      seen.add(start2);
+      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/bko/a1-stable-motif.ts
+var MIN_INSTANCES = 5;
+var MIN_SURVIVED_RUNS = 2;
+function a1StableMotif(input) {
+  if (input.instanceCount >= MIN_INSTANCES && input.survivedRuns >= MIN_SURVIVED_RUNS) {
+    return {
+      shouldMarkStable: true,
+      confidence: Math.min(1, input.instanceCount / 20),
+      rule: "A1"
+    };
+  }
+  return { shouldMarkStable: false, confidence: 0, rule: "A1" };
+}
+
+// ../../packages/math/src/bko/a2-motif-quality.ts
+var MIN_INSTANCES2 = 3;
+var MIN_QUALITY = 0.65;
+var MAX_FAILURE_RATE = 0.15;
+var QUALITY_BOOST = 1.2;
+function a2MotifQuality(input) {
+  if (input.instances.length === 0) {
+    return {
+      qualityScore: 0,
+      qualityFailureRate: 0,
+      qualified: false,
+      qualityBoost: 1,
+      rule: "A2"
+    };
+  }
+  const mean = input.instances.reduce((s, i2) => s + i2.confidence, 0) / input.instances.length;
+  const failures = input.instances.filter((i2) => i2.failed).length;
+  const failureRate = failures / input.instances.length;
+  const qualified = input.instances.length >= MIN_INSTANCES2 && mean >= MIN_QUALITY && failureRate <= MAX_FAILURE_RATE;
+  return {
+    qualityScore: mean,
+    qualityFailureRate: failureRate,
+    qualified,
+    qualityBoost: qualified ? QUALITY_BOOST : 1,
+    rule: "A2"
+  };
+}
+
+// ../../packages/math/src/motif-gate.ts
+var MOTIF_MIN_MEMBERS = 5;
+var MOTIF_MIN_SURVIVED = 2;
+function motifDecision(input) {
+  if (input.memberCount < MOTIF_MIN_MEMBERS) {
+    return {
+      isCandidate: false,
+      survivedRuns: input.priorSurvivedRuns,
+      stable: false,
+      qualified: false,
+      promoted: false,
+      motifConfidence: 0
+    };
+  }
+  const survivedRuns = input.priorSurvivedRuns + 1;
+  const a2 = a2MotifQuality({ instances: input.instances });
+  const a1 = a1StableMotif({ instanceCount: input.instanceCount, survivedRuns });
+  const stable = a1.shouldMarkStable;
+  const promoted = survivedRuns >= MOTIF_MIN_SURVIVED && stable && a2.qualified;
+  return {
+    isCandidate: true,
+    survivedRuns,
+    stable,
+    qualified: a2.qualified,
+    promoted,
+    motifConfidence: Math.round(a2.qualityScore * 100) / 100
+  };
+}
+
+// ../../packages/math/src/pagerank-local.ts
+function pagerankLocal(input) {
+  const damping = input.damping ?? 0.85;
+  const tol = input.tolerance ?? 1e-6;
+  const maxIter = input.maxIterations ?? 100;
+  const ids = input.regionIds;
+  const n = ids.length;
+  if (n === 0 || input.globalN === 0) {
+    return { scores: /* @__PURE__ */ new Map(), iterations: 0, converged: true };
+  }
+  const index = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < n; i2++) index.set(ids[i2], i2);
+  const base = (1 - damping) / input.globalN;
+  const outSum = new Float64Array(n);
+  const inflow = new Float64Array(n);
+  let score2 = new Float64Array(n);
+  for (let i2 = 0; i2 < n; i2++) {
+    const id = ids[i2];
+    outSum[i2] = input.outSum.get(id) ?? 0;
+    inflow[i2] = input.boundaryInflow.get(id) ?? 0;
+    score2[i2] = input.rank0.get(id) ?? base;
+  }
+  const rowLen = new Int32Array(n);
+  let edgeCount = 0;
+  for (const [from, edges] of input.out) {
+    const fi = index.get(from);
+    if (fi === void 0) continue;
+    let inSet = 0;
+    for (const e of edges) if (index.has(e.to)) inSet++;
+    rowLen[fi] = inSet;
+    edgeCount += inSet;
+  }
+  const rowStart = new Int32Array(n + 1);
+  for (let i2 = 0; i2 < n; i2++) rowStart[i2 + 1] = rowStart[i2] + rowLen[i2];
+  const colIdx = new Int32Array(edgeCount);
+  const colW = new Float64Array(edgeCount);
+  const cursor = rowStart.slice(0, n);
+  for (const [from, edges] of input.out) {
+    const fi = index.get(from);
+    if (fi === void 0) continue;
+    for (const e of edges) {
+      const ti = index.get(e.to);
+      if (ti === void 0) continue;
+      const c = cursor[fi];
+      cursor[fi] = c + 1;
+      colIdx[c] = ti;
+      colW[c] = e.weight;
+    }
+  }
+  const externalDangling = input.externalDanglingRank ?? 0;
+  let next = new Float64Array(n);
+  let iter = 0;
+  let converged = false;
+  for (; iter < maxIter; iter++) {
+    let internalDangling = 0;
+    for (let i2 = 0; i2 < n; i2++) if (outSum[i2] <= 0) internalDangling += score2[i2];
+    const danglingShare = damping * (internalDangling + externalDangling) / input.globalN;
+    for (let i2 = 0; i2 < n; i2++) next[i2] = base + danglingShare + damping * inflow[i2];
+    for (let i2 = 0; i2 < n; i2++) {
+      const os2 = outSum[i2];
+      if (os2 <= 0) continue;
+      const f = damping * score2[i2] / os2;
+      const end = rowStart[i2 + 1];
+      for (let c = rowStart[i2]; c < end; c++) next[colIdx[c]] += f * colW[c];
+    }
+    let diff = 0;
+    for (let i2 = 0; i2 < n; i2++) diff += Math.abs(next[i2] - score2[i2]);
+    const tmp = score2;
+    score2 = next;
+    next = tmp;
+    if (diff < tol) {
+      iter++;
+      converged = true;
+      break;
+    }
+  }
+  const scores = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < n; i2++) scores.set(ids[i2], score2[i2]);
+  return { scores, iterations: iter, converged };
+}
+
 // ../../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,
@@ -25569,6 +26038,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
@@ -25581,6 +26053,12 @@ 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;
 -- 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
@@ -25667,6 +26145,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);
@@ -25683,6 +26162,7 @@ var SqliteGraphStore = class {
     this.db.exec(TEMPORAL_INDEX_SQL);
     installHistoryCacheFloor(this.db);
     installEditPlaceholderRetirement(this.db);
+    installCloudAttrCompaction(this.db);
     if (!this.db.prepare("SELECT value FROM store_meta WHERE key = ?").get(SESSION_REPAIR_KEY)) {
       this.db.transaction(() => {
         this.repairSessionAliases();
@@ -26180,1999 +26660,1613 @@ 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). */
-  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)
-    }));
-  }
-  *iterateNodeIdentitiesByLabel(label, pageSize = 2e3) {
-    const page = this.db.prepare(
-      "SELECT rowid AS rid, id, json_extract(attrs_json, '$.relPath') AS relPath, json_extract(attrs_json, '$.qname') AS qname FROM nodes WHERE rowid > ? AND label = ? AND valid_to IS NULL ORDER BY rowid LIMIT ?"
-    );
-    let after = 0;
-    for (; ; ) {
-      const rows = page.all(after, label, pageSize);
-      for (const r of rows) {
-        yield {
-          id: r.id,
-          relPath: typeof r.relPath === "string" ? r.relPath : null,
-          qname: typeof r.qname === "string" ? r.qname : null
-        };
-      }
-      if (rows.length < pageSize) return;
-      after = rows[rows.length - 1].rid;
-    }
-  }
-  recentNodeIds(label, limit) {
-    const rows = this.db.prepare("SELECT id FROM nodes WHERE label = ? AND valid_to IS NULL ORDER BY last_updated_at DESC LIMIT ?").all(label, Math.max(0, limit));
-    return rows.map((r) => r.id);
-  }
-  recentOpenProblemCandidates(opts) {
-    if (!Number.isSafeInteger(opts.limit) || opts.limit < 0) {
-      throw new RangeError("candidate limit must be a non-negative safe integer");
-    }
-    return this.db.prepare(`SELECT id, description FROM nodes
-      WHERE label = 'Problem' AND valid_to IS NULL
-        AND json_extract(attrs_json, '$.resolvedAt') IS NULL
-        AND json_type(attrs_json, '$.mergedInto') IS NULL
-        AND (? IS NULL OR id != ?)
-        AND (json_type(attrs_json, '$.workspaceId') IS NULL OR json_extract(attrs_json, '$.workspaceId') = ?)
-        AND COALESCE(json_extract(attrs_json, '$.kind') = 'constraint', 0) = ?
-      ORDER BY last_updated_at DESC, rowid ASC LIMIT ?`).all(
-      opts.excludeId ?? null,
-      opts.excludeId ?? null,
-      opts.workspaceId,
-      opts.constraint ? 1 : 0,
-      opts.limit
-    );
-  }
-  hasLiveNodes() {
-    const r = this.db.prepare("SELECT EXISTS(SELECT 1 FROM nodes WHERE valid_to IS NULL) AS e").get();
-    return r.e === 1;
-  }
-  findNodeIdentitiesByLabel(label) {
-    const rows = this.stmts.identitiesByLabel.all(label);
-    return rows.map((r) => ({
-      id: r.id,
-      relPath: typeof r.relPath === "string" ? r.relPath : null,
-      qname: typeof r.qname === "string" ? r.qname : null
-    }));
-  }
-  findAllVersionsByLabel(label, attribute) {
-    if (attribute && !/^[A-Za-z0-9_]+(\.[A-Za-z0-9_]+)*$/.test(attribute.path)) {
-      throw new Error(`invalid attr path: ${attribute.path}`);
-    }
-    const rows = attribute ? this.db.prepare(`SELECT * FROM nodes WHERE json_extract(attrs_json, '$.${attribute.path}') = ? AND label = ?`).all(attribute.value, label) : this.stmts.findByLabelAll.all(label);
-    return rows.map(rowToNode);
-  }
-  searchNodes(opts) {
-    const where = [];
-    const params = {};
-    if (opts.labels && opts.labels.length > 0) {
-      const placeholders = opts.labels.map((_, i2) => `:label${i2}`).join(", ");
-      where.push(`label IN (${placeholders})`);
-      opts.labels.forEach((l, i2) => {
-        params[`label${i2}`] = l;
-      });
-    }
-    if (opts.descriptionLike) {
-      where.push("description LIKE :descPat");
-      params["descPat"] = `%${opts.descriptionLike}%`;
-    }
-    where.push("valid_to IS NULL");
-    const limit = Math.max(1, opts.limit ?? 50);
-    params["limit"] = limit;
-    const whereSql = where.length > 0 ? "WHERE " + where.join(" AND ") : "";
-    const sql = `SELECT * FROM nodes ${whereSql} ORDER BY page_rank DESC, last_updated_at DESC LIMIT :limit`;
-    const rows = this.db.prepare(sql).all(params);
-    return rows.map(rowToNode);
-  }
-  searchDescriptionTerms(terms, limit) {
-    if (terms.length === 0) return [];
-    const score2 = terms.map(() => "(description LIKE ?)").join(" + ");
-    const rows = this.db.prepare(
-      `SELECT n.*, h.m AS matched
-           FROM (SELECT rowid AS rid, ${score2} AS m
-                   FROM nodes INDEXED BY nodes_live_description
-                  WHERE valid_to IS NULL) h
-           JOIN nodes n ON n.rowid = h.rid
-          WHERE h.m > 0
-          ORDER BY h.m DESC, n.page_rank DESC, n.last_updated_at DESC
-          LIMIT ?`
-    ).all(...terms.map((t) => `%${t}%`), Math.max(1, limit));
-    return rows.map((r) => ({ node: rowToNode(r), matched: Number(r.matched) }));
-  }
-  typedEdgeStmt(sql) {
-    let stmt = this.typedEdgeStmts.get(sql);
-    if (!stmt) {
-      stmt = this.db.prepare(sql);
-      this.typedEdgeStmts.set(sql, stmt);
-    }
-    return stmt;
-  }
-  outEdges(nodeId, types) {
-    if (!types || types.length === 0) {
-      const rows2 = this.stmts.outEdges.all(nodeId);
-      return rows2.map(rowToEdge);
-    }
-    const placeholders = types.map((_, i2) => `:t${i2}`).join(",");
-    const params = { from_id: nodeId };
-    types.forEach((t, i2) => {
-      params[`t${i2}`] = t;
-    });
-    const rows = this.typedEdgeStmt(
-      `SELECT * FROM edges WHERE from_id = :from_id AND type IN (${placeholders}) AND valid_to IS NULL`
-    ).all(params);
-    return rows.map(rowToEdge);
-  }
-  inEdges(nodeId, types) {
-    if (!types || types.length === 0) {
-      const rows2 = this.stmts.inEdges.all(nodeId);
-      return rows2.map(rowToEdge);
-    }
-    const placeholders = types.map((_, i2) => `:t${i2}`).join(",");
-    const params = { to_id: nodeId };
-    types.forEach((t, i2) => {
-      params[`t${i2}`] = t;
-    });
-    const rows = this.typedEdgeStmt(
-      `SELECT * FROM edges WHERE to_id = :to_id AND type IN (${placeholders}) AND valid_to IS NULL`
-    ).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);
-    for (const e of edges) {
-      const n = this.getNode(e.to);
-      if (n) out2.push({ edgeType: e.type, confidence: e.confidence, node: n });
-    }
-    const inE = this.inEdges(nodeId, types);
-    for (const e of inE) {
-      const n = this.getNode(e.from);
-      if (n) out2.push({ edgeType: e.type, confidence: e.confidence, node: n });
-    }
-    return out2;
-  }
-  nodeCount() {
-    return Number(this.stmts.nodeCount.get().n);
-  }
-  mutationCount() {
-    return this.mutations;
-  }
-  currentIngestSeq() {
-    return this.ingestSeq;
-  }
-  nextIngestSeq() {
-    this.ingestSeq += 1;
-    this.stmts.setIngestSeq.run({ v: String(this.ingestSeq) });
-    return this.ingestSeq;
-  }
-  edgeCount() {
-    return Number(this.stmts.edgeCount.get().n);
-  }
-  // Lightweight whole-graph scans — select only the columns the caller needs so a
-  // 100k-node pass skips the per-row attrs JSON.parse + embedding decode rowToNode
-  // does. Live rows only (valid_to IS NULL), matching findNodesByLabel/outEdges.
-  scanLiveNodes() {
-    const rows = this.db.prepare("SELECT id, label, memory_tier, page_rank, is_landmark FROM nodes WHERE valid_to IS NULL").all();
+  findNodeAttrsByLabel(label) {
+    const rows = this.stmts.attrsByLabel.all(label);
     return rows.map((r) => ({
       id: r.id,
-      label: r.label,
-      memoryTier: r.memory_tier,
-      pageRank: r.page_rank,
-      isLandmark: r.is_landmark === 1
+      createdAt: r.created_at,
+      ...r.created_at_seq != null ? { createdAtSeq: r.created_at_seq } : {},
+      attrs: JSON.parse(r.attrs_json)
     }));
   }
-  scanLiveEdges() {
-    const rows = this.db.prepare("SELECT from_id, to_id, type FROM edges WHERE valid_to IS NULL").all();
-    return rows.map((r) => ({ from: r.from_id, to: r.to_id, type: r.type }));
-  }
-  getMeta(key) {
-    const r = this.db.prepare("SELECT value FROM store_meta WHERE key = ?").get(key);
-    return r?.value ?? null;
-  }
-  setMeta(key, value) {
-    this.db.prepare(
-      "INSERT INTO store_meta (key, value) VALUES (:key, :value) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
-    ).run({ key, value });
+  *iterateNodeIdentitiesByLabel(label, pageSize = 2e3) {
+    const page = this.db.prepare(
+      "SELECT rowid AS rid, id, json_extract(attrs_json, '$.relPath') AS relPath, json_extract(attrs_json, '$.qname') AS qname FROM nodes WHERE rowid > ? AND label = ? AND valid_to IS NULL ORDER BY rowid LIMIT ?"
+    );
+    let after = 0;
+    for (; ; ) {
+      const rows = page.all(after, label, pageSize);
+      for (const r of rows) {
+        yield {
+          id: r.id,
+          relPath: typeof r.relPath === "string" ? r.relPath : null,
+          qname: typeof r.qname === "string" ? r.qname : null
+        };
+      }
+      if (rows.length < pageSize) return;
+      after = rows[rows.length - 1].rid;
+    }
   }
-  dirtyNodeIdsSince(ts) {
-    const rows = this.db.prepare("SELECT id FROM nodes WHERE valid_to IS NULL AND last_updated_at > ?").all(ts);
+  recentNodeIds(label, limit) {
+    const rows = this.db.prepare("SELECT id FROM nodes WHERE label = ? AND valid_to IS NULL ORDER BY last_updated_at DESC LIMIT ?").all(label, Math.max(0, limit));
     return rows.map((r) => r.id);
   }
-  labelFingerprint(labels) {
-    if (labels.length === 0) return "0";
-    if (labels.length === FINGERPRINT_INDEXED_LABELS.length && FINGERPRINT_INDEXED_LABELS.every((l) => labels.includes(l))) {
-      const r2 = this.db.prepare(
-        `SELECT COUNT(*) AS n, MAX(last_updated_at) AS t,
-                  MAX(COALESCE(last_reinforced_at_seq, created_at_seq, 0)) AS s
-             FROM nodes INDEXED BY nodes_instance_fingerprint_v2
-            WHERE valid_to IS NULL AND label IN ('Problem','Vulnerability','Solution','RootCause')`
-      ).get();
-      return `${r2.n}:${r2.t ?? 0}:${r2.s ?? 0}`;
+  recentOpenProblemCandidates(opts) {
+    if (!Number.isSafeInteger(opts.limit) || opts.limit < 0) {
+      throw new RangeError("candidate limit must be a non-negative safe integer");
     }
-    const r = this.db.prepare(
-      `SELECT COUNT(*) AS n, MAX(last_updated_at) AS t,
-                MAX(COALESCE(last_reinforced_at_seq, created_at_seq, 0)) AS s
-           FROM nodes WHERE valid_to IS NULL AND label IN (${labels.map(() => "?").join(",")})`
-    ).get(...labels);
-    return `${r.n}:${r.t ?? 0}:${r.s ?? 0}`;
-  }
-  /** Endpoints of edges TOUCHED since `ts` — created, re-seen, or CLOSED.
-   *  Closures matter as much as additions: a node that lost inflow is rank-dirty
-   *  while its own row never updated, so removal endpoints must seed the
-   *  incremental region or the stale inflow persists until the full backstop. */
-  edgeEndpointsTouchedSince(ts) {
-    const rows = this.db.prepare(
-      `SELECT from_id, to_id FROM edges
-         WHERE (valid_to IS NULL AND (created_at > :ts OR last_seen_at > :ts))
-            OR (valid_to IS NOT NULL AND valid_to > :ts)`
-    ).all({ ts });
-    return rows.map((r) => ({ from: r.from_id, to: r.to_id }));
-  }
-  /** Lightweight out-edges for a SET of sources, chunked IN-lists — the region
-   *  assembly path for incremental PageRank (per-node outEdges() at region
-   *  scale re-creates the 106k-prepared-calls problem the batch scan solved). */
-  outEdgesForMany(ids) {
-    return this.edgesForMany(ids, "from_id");
-  }
-  inEdgesForMany(ids) {
-    return this.edgesForMany(ids, "to_id");
+    return this.db.prepare(`SELECT id, description FROM nodes
+      WHERE label = 'Problem' AND valid_to IS NULL
+        AND json_extract(attrs_json, '$.resolvedAt') IS NULL
+        AND json_type(attrs_json, '$.mergedInto') IS NULL
+        AND (? IS NULL OR id != ?)
+        AND (json_type(attrs_json, '$.workspaceId') IS NULL OR json_extract(attrs_json, '$.workspaceId') = ?)
+        AND COALESCE(json_extract(attrs_json, '$.kind') = 'constraint', 0) = ?
+      ORDER BY last_updated_at DESC, rowid ASC LIMIT ?`).all(
+      opts.excludeId ?? null,
+      opts.excludeId ?? null,
+      opts.workspaceId,
+      opts.constraint ? 1 : 0,
+      opts.limit
+    );
   }
-  /** Stored pageRank for a SET of ids (live rows only — a closed id is simply
-   *  absent, which is how incremental region assembly drops dead endpoints). */
-  ranksForMany(ids) {
-    const out2 = /* @__PURE__ */ new Map();
-    const CHUNK = 400;
-    for (let i2 = 0; i2 < ids.length; i2 += CHUNK) {
-      const chunk = ids.slice(i2, i2 + CHUNK);
-      const placeholders = chunk.map(() => "?").join(", ");
-      const rows = this.db.prepare(
-        `SELECT id, page_rank FROM nodes WHERE id IN (${placeholders}) AND valid_to IS NULL`
-      ).all(...chunk);
-      for (const r of rows) out2.set(r.id, r.page_rank);
-    }
-    return out2;
+  hasLiveNodes() {
+    const r = this.db.prepare("SELECT EXISTS(SELECT 1 FROM nodes WHERE valid_to IS NULL) AS e").get();
+    return r.e === 1;
   }
-  /** The minimal row set the landmark sweep needs — landmark CANDIDATES
-   *  (Pattern/RootCause), everything currently flagged, and every
-   *  persistent-tier node (force-landmarks). A few thousand rows, so the
-   *  incremental path can refresh the GLOBAL landmark set without the 179k-row
-   *  scanLiveNodes materialization. */
-  landmarkSweepRows() {
-    const rows = this.db.prepare(
-      `SELECT id, label, page_rank, is_landmark, memory_tier, extraction_source FROM nodes
-         WHERE valid_to IS NULL
-           AND (memory_tier = 'persistent' OR is_landmark = 1 OR label IN ('Pattern', 'RootCause'))`
-    ).all();
+  findNodeIdentitiesByLabel(label) {
+    const rows = this.stmts.identitiesByLabel.all(label);
     return rows.map((r) => ({
       id: r.id,
-      label: r.label,
-      pageRank: r.page_rank,
-      isLandmark: r.is_landmark === 1,
-      memoryTier: r.memory_tier,
-      extractionSource: r.extraction_source
+      relPath: typeof r.relPath === "string" ? r.relPath : null,
+      qname: typeof r.qname === "string" ? r.qname : null
     }));
   }
-  edgesForMany(ids, col) {
-    const out2 = [];
-    const CHUNK = 400;
-    for (let i2 = 0; i2 < ids.length; i2 += CHUNK) {
-      const chunk = ids.slice(i2, i2 + CHUNK);
-      const placeholders = chunk.map(() => "?").join(", ");
-      const rows = this.db.prepare(
-        `SELECT from_id, to_id, type FROM edges WHERE ${col} IN (${placeholders}) AND valid_to IS NULL`
-      ).all(...chunk);
-      for (const r of rows) out2.push({ from: r.from_id, to: r.to_id, type: r.type });
+  findAllVersionsByLabel(label, attribute) {
+    if (attribute && !/^[A-Za-z0-9_]+(\.[A-Za-z0-9_]+)*$/.test(attribute.path)) {
+      throw new Error(`invalid attr path: ${attribute.path}`);
     }
-    return out2;
+    const rows = attribute ? this.db.prepare(`SELECT * FROM nodes WHERE json_extract(attrs_json, '$.${attribute.path}') = ? AND label = ?`).all(attribute.value, label) : this.stmts.findByLabelAll.all(label);
+    return rows.map(rowToNode);
   }
-  checkpointWal() {
-    try {
-      const r = this.db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
-      return r ?? null;
-    } catch {
-      return null;
+  searchNodes(opts) {
+    const where = [];
+    const params = {};
+    if (opts.labels && opts.labels.length > 0) {
+      const placeholders = opts.labels.map((_, i2) => `:label${i2}`).join(", ");
+      where.push(`label IN (${placeholders})`);
+      opts.labels.forEach((l, i2) => {
+        params[`label${i2}`] = l;
+      });
     }
-  }
-  reviveReobserved(relPaths, workspaceId, since) {
-    let revived = 0;
-    const CHUNK = 400;
-    for (let i2 = 0; i2 < relPaths.length; i2 += CHUNK) {
-      const slice = relPaths.slice(i2, i2 + CHUNK);
-      if (slice.length === 0) continue;
-      const r = this.db.prepare(
-        `UPDATE nodes SET valid_to = NULL
-             WHERE valid_to IS NOT NULL
-               AND last_updated_at >= ?
-               AND json_extract(attrs_json, '$.workspaceId') = ?
-               AND json_extract(attrs_json, '$.relPath') IN (${slice.map(() => "?").join(",")})`
-      ).run(since, workspaceId, ...slice);
-      revived += Number(r.changes);
+    if (opts.descriptionLike) {
+      where.push("description LIKE :descPat");
+      params["descPat"] = `%${opts.descriptionLike}%`;
     }
-    if (revived > 0) this.mutations++;
-    return revived;
+    where.push("valid_to IS NULL");
+    const limit = Math.max(1, opts.limit ?? 50);
+    params["limit"] = limit;
+    const whereSql = where.length > 0 ? "WHERE " + where.join(" AND ") : "";
+    const sql = `SELECT * FROM nodes ${whereSql} ORDER BY page_rank DESC, last_updated_at DESC LIMIT :limit`;
+    const rows = this.db.prepare(sql).all(params);
+    return rows.map(rowToNode);
   }
-  recentEdgeAttrCoverage(marker, attr, limit) {
-    const r = this.db.prepare(
-      `SELECT COUNT(*) AS total,
-                COALESCE(SUM(CASE WHEN json_extract(attrs_json, '$.' || ?) = 1 THEN 1 ELSE 0 END), 0) AS count
-           FROM (SELECT attrs_json FROM edges
-                  WHERE valid_to IS NULL AND attrs_json LIKE ?
-                  ORDER BY created_at DESC LIMIT ?)`
-    ).get(attr, `%${marker}%`, limit);
-    return { count: Number(r.count), total: Number(r.total) };
+  searchDescriptionTerms(terms, limit) {
+    if (terms.length === 0) return [];
+    const score2 = terms.map(() => "(description LIKE ?)").join(" + ");
+    const rows = this.db.prepare(
+      `SELECT n.*, h.m AS matched
+           FROM (SELECT rowid AS rid, ${score2} AS m
+                   FROM nodes INDEXED BY nodes_live_description
+                  WHERE valid_to IS NULL) h
+           JOIN nodes n ON n.rowid = h.rid
+          WHERE h.m > 0
+          ORDER BY h.m DESC, n.page_rank DESC, n.last_updated_at DESC
+          LIMIT ?`
+    ).all(...terms.map((t) => `%${t}%`), Math.max(1, limit));
+    return rows.map((r) => ({ node: rowToNode(r), matched: Number(r.matched) }));
   }
-  liveNodeIds(ids) {
-    const live = /* @__PURE__ */ new Set();
-    const CHUNK = 900;
-    for (let i2 = 0; i2 < ids.length; i2 += CHUNK) {
-      const slice = ids.slice(i2, i2 + CHUNK);
-      if (slice.length === 0) continue;
-      const rows = this.db.prepare(
-        `SELECT id FROM nodes WHERE valid_to IS NULL AND id IN (${slice.map(() => "?").join(",")})`
-      ).all(...slice);
-      for (const r of rows) live.add(r.id);
-    }
-    return live;
+  searchTextCandidates(terms) {
+    if (terms.length === 0) return [];
+    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 }));
+  }
+  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;
   }
-  /**
-   * Live edges WITH their endpoint labels and ids, resolved in ONE join.
-   *
-   * The ontology sweep needs (id, type, fromLabel, toLabel) for every live edge.
-   * Doing that as `scanLiveEdges()` + two `getNode()` calls is 2N node reads —
-   * 550,000 on this store — and each one deserializes the node's embedding blob.
-   * Measured: the sweep did not finish in 10 minutes. As a single join it is one
-   * query over an index-covered scan. Labels only; nothing here touches embeddings.
-   */
-  scanLiveEdgeRows() {
-    const rows = this.db.prepare(
-      `SELECT e.id, e.from_id, e.to_id, e.type, a.label AS from_label, b.label AS to_label
-         FROM edges e
-         LEFT JOIN nodes a ON a.id = e.from_id AND a.valid_to IS NULL
-         LEFT JOIN nodes b ON b.id = e.to_id   AND b.valid_to IS NULL
-         WHERE e.valid_to IS NULL`
-    ).all();
-    return rows.map((r) => ({
-      id: r.id,
-      from: r.from_id,
-      to: r.to_id,
-      type: r.type,
-      fromLabel: r.from_label ?? void 0,
-      toLabel: r.to_label ?? void 0
-    }));
+  typedEdgeStmt(sql) {
+    let stmt = this.typedEdgeStmts.get(sql);
+    if (!stmt) {
+      stmt = this.db.prepare(sql);
+      this.typedEdgeStmts.set(sql, stmt);
+    }
+    return stmt;
   }
-  /** 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));
+  outEdges(nodeId, types) {
+    if (!types || types.length === 0) {
+      const rows2 = this.stmts.outEdges.all(nodeId);
+      return rows2.map(rowToEdge);
     }
-    return out2;
+    const placeholders = types.map((_, i2) => `:t${i2}`).join(",");
+    const params = { from_id: nodeId };
+    types.forEach((t, i2) => {
+      params[`t${i2}`] = t;
+    });
+    const rows = this.typedEdgeStmt(
+      `SELECT * FROM edges WHERE from_id = :from_id AND type IN (${placeholders}) AND valid_to IS NULL`
+    ).all(params);
+    return rows.map(rowToEdge);
   }
-  nodesByRelPath(relPaths) {
-    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})`
-    ).all(...relPaths);
-    return rows.map(rowToNode);
+  inEdges(nodeId, types) {
+    if (!types || types.length === 0) {
+      const rows2 = this.stmts.inEdges.all(nodeId);
+      return rows2.map(rowToEdge);
+    }
+    const placeholders = types.map((_, i2) => `:t${i2}`).join(",");
+    const params = { to_id: nodeId };
+    types.forEach((t, i2) => {
+      params[`t${i2}`] = t;
+    });
+    const rows = this.typedEdgeStmt(
+      `SELECT * FROM edges WHERE to_id = :to_id AND type IN (${placeholders}) AND valid_to IS NULL`
+    ).all(params);
+    return rows.map(rowToEdge);
   }
-  findLiveNodesByAttr(label, attrPath, value) {
-    if (!/^[A-Za-z0-9_]+(\.[A-Za-z0-9_]+)*$/.test(attrPath)) throw new Error(`invalid attr path: ${attrPath}`);
+  /** 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 * FROM nodes WHERE json_extract(attrs_json, '$.${attrPath}') = ? AND valid_to IS NULL AND label = ?`
-    ).all(value, label);
-    return rows.map(rowToNode);
+      `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)]));
   }
-  // ── Bi-temporal versioning ───────────────────────────────────────────
-  // NOTE: the adapter's transaction() is non-reentrant (raw BEGIN/COMMIT), and
-  // the indexer calls freezeNode inside its own store.transaction(). So this
-  // method does NOT open a transaction — callers needing atomicity wrap it.
-  freezeNode(liveId, t) {
-    const live = this.getNode(liveId);
-    if (!live) return null;
-    const version3 = live.version ?? 1;
-    const frozenId = `${liveId}@v${version3}`;
-    if (this.getNode(frozenId)) {
-      this.stmts.advanceLive.run({ live_id: liveId, t });
-      return frozenId;
+  neighbors(nodeId, types) {
+    const out2 = [];
+    const edges = this.outEdges(nodeId, types);
+    for (const e of edges) {
+      const n = this.getNode(e.to);
+      if (n) out2.push({ edgeType: e.type, confidence: e.confidence, node: n });
     }
-    this.stmts.freezeCopy.run({ frozen_id: frozenId, live_id: liveId, t });
-    this.mergeEdge({
-      id: `edge_superseded_${frozenId}`,
-      from: frozenId,
-      to: liveId,
-      type: "SUPERSEDED_BY",
-      confidence: 1,
-      extractionSource: "daemon-extracted",
-      createdAt: t,
-      lastSeenAt: t,
-      navSuccesses: 0,
-      navFailures: 0,
-      validFrom: t,
-      validTo: null,
-      attrs: {}
-    });
-    this.stmts.advanceLive.run({ live_id: liveId, t });
-    return frozenId;
+    const inE = this.inEdges(nodeId, types);
+    for (const e of inE) {
+      const n = this.getNode(e.from);
+      if (n) out2.push({ edgeType: e.type, confidence: e.confidence, node: n });
+    }
+    return out2;
   }
-  closeNode(id, t) {
-    this.stmts.closeNode.run({ id, t });
+  nodeCount() {
+    return Number(this.stmts.nodeCount.get().n);
   }
-  closeEdge(id, t) {
-    this.stmts.closeEdge.run({ id, t });
+  mutationCount() {
+    return this.mutations;
   }
-  nodeHistory(logicalId) {
-    const rows = this.stmts.nodeHistory.all(logicalId);
-    return rows.map(rowToNode);
+  currentIngestSeq() {
+    return this.ingestSeq;
   }
-  nodesAsOf(t) {
-    const rows = this.stmts.nodesAsOf.all({ t });
-    return rows.map(rowToNode);
+  nextIngestSeq() {
+    this.ingestSeq += 1;
+    this.stmts.setIngestSeq.run({ v: String(this.ingestSeq) });
+    return this.ingestSeq;
   }
-  /** `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);
+  edgeCount() {
+    return Number(this.stmts.edgeCount.get().n);
   }
-  edgesAsOf(t) {
-    const rows = this.stmts.edgesAsOf.all({ t });
-    return rows.map(rowToEdge);
+  // Lightweight whole-graph scans — select only the columns the caller needs so a
+  // 100k-node pass skips the per-row attrs JSON.parse + embedding decode rowToNode
+  // does. Live rows only (valid_to IS NULL), matching findNodesByLabel/outEdges.
+  scanLiveNodes() {
+    const rows = this.db.prepare("SELECT id, label, memory_tier, page_rank, is_landmark FROM nodes WHERE valid_to IS NULL").all();
+    return rows.map((r) => ({
+      id: r.id,
+      label: r.label,
+      memoryTier: r.memory_tier,
+      pageRank: r.page_rank,
+      isLandmark: r.is_landmark === 1
+    }));
   }
-  transaction(fn) {
-    return this.db.transaction(fn);
+  scanLiveEdges() {
+    const rows = this.db.prepare("SELECT from_id, to_id, type FROM edges WHERE valid_to IS NULL").all();
+    return rows.map((r) => ({ from: r.from_id, to: r.to_id, type: r.type }));
   }
-  close() {
-    this.db.close();
+  getMeta(key) {
+    const r = this.db.prepare("SELECT value FROM store_meta WHERE key = ?").get(key);
+    return r?.value ?? null;
   }
-};
-function openGraphStore(opts) {
-  return new SqliteGraphStore(opts);
-}
-
-// ../../packages/local-graph/src/traversal.ts
-init_src2();
-var MAX_EDGE_WEIGHT = Math.max(...Object.values(EDGE_WEIGHT));
-var CAUSAL_FAMILY = [
-  ...CAUSAL_EDGES,
-  ...RESOLUTION_EDGES
-];
-
-// ../../packages/local-graph/src/justification.ts
-init_src();
-init_src2();
-function addDependency(store2, opts) {
-  const id = digest({ from: opts.fromId, type: "DEPENDS_ON", to: opts.toId });
-  const attrs = { relation: opts.relation };
-  if (opts.introduced !== void 0) attrs.introduced = opts.introduced;
-  if (opts.fixed !== void 0) attrs.fixed = opts.fixed;
-  if (opts.evidence !== void 0) attrs.evidence = opts.evidence;
-  const edge = {
-    id,
-    from: opts.fromId,
-    to: opts.toId,
-    type: "DEPENDS_ON",
-    confidence: 1,
-    extractionSource: opts.extractionSource ?? "agent-observed",
-    createdAt: opts.ts,
-    lastSeenAt: opts.ts,
-    navSuccesses: 0,
-    navFailures: 0,
-    attrs
-  };
-  store2.mergeEdge(edge);
-  return edge;
-}
-function markRevisit(store2, node, reason, ts, answeredWhen) {
-  const fresh = store2.getNode(node.id) ?? node;
-  if (fresh.validTo != null || fresh.attrs["retiredReason"]) return;
-  store2.updateNode(node.id, {
-    attrs: {
-      ...fresh.attrs,
-      revisit: true,
-      revisitReason: reason,
-      revisitSinceTs: ts,
-      revisitAnsweredWhen: answeredWhen
-    },
-    lastUpdatedAt: ts
-  });
-}
-var LEGACY_AUTO_CLOSE_ASK = "auto-closed off a pre-provenance anchor";
-var KNOWN_CONDITIONS = {
-  parentProblemOpen: true,
-  dependentStale: true
-};
-function isRevisitCondition(v) {
-  return typeof v === "string" && Object.prototype.hasOwnProperty.call(KNOWN_CONDITIONS, v);
-}
-function conditionOf(node) {
-  const explicit = node.attrs["revisitAnsweredWhen"];
-  if (isRevisitCondition(explicit)) return explicit;
-  if (String(node.attrs["revisitReason"] ?? "").startsWith(LEGACY_AUTO_CLOSE_ASK)) {
-    return "parentProblemOpen";
+  setMeta(key, value) {
+    this.db.prepare(
+      "INSERT INTO store_meta (key, value) VALUES (:key, :value) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+    ).run({ key, value });
   }
-  return void 0;
-}
-function clearAnsweredRevisits(store2, ts) {
-  const report = { cleared: 0, standing: 0 };
-  for (const label of SEMANTIC_NODE_LABELS) {
-    for (const node of store2.findNodesByLabel(label)) {
-      if (node.attrs["revisit"] !== true) continue;
-      const condition = conditionOf(node);
-      if (condition === void 0 || !isRevisitAnswered(store2, node, condition)) {
-        report.standing++;
-        continue;
-      }
-      clearRevisit(store2, node.id, ts);
-      report.cleared++;
-    }
+  dirtyNodeIdsSince(ts) {
+    const rows = this.db.prepare("SELECT id FROM nodes WHERE valid_to IS NULL AND last_updated_at > ?").all(ts);
+    return rows.map((r) => r.id);
   }
-  return report;
-}
-function isRevisitAnswered(store2, node, condition) {
-  switch (condition) {
-    case "parentProblemOpen": {
-      const parents = store2.inEdges(node.id, ["SOLVED_BY"]).map((e) => store2.getNode(e.from)).filter((n) => n !== null && n.validTo == null);
-      return parents.every((p) => p.attrs["resolvedAt"] == null);
-    }
-    case "dependentStale": {
-      const since = Number(node.attrs["revisitSinceTs"] ?? 0);
-      return since > 0 && node.lastUpdatedAt > since;
+  labelFingerprint(labels) {
+    if (labels.length === 0) return "0";
+    if (labels.length === FINGERPRINT_INDEXED_LABELS.length && FINGERPRINT_INDEXED_LABELS.every((l) => labels.includes(l))) {
+      const r2 = this.db.prepare(
+        `SELECT COUNT(*) AS n, MAX(last_updated_at) AS t,
+                  MAX(COALESCE(last_reinforced_at_seq, created_at_seq, 0)) AS s
+             FROM nodes INDEXED BY nodes_instance_fingerprint_v2
+            WHERE valid_to IS NULL AND label IN ('Problem','Vulnerability','Solution','RootCause')`
+      ).get();
+      return `${r2.n}:${r2.t ?? 0}:${r2.s ?? 0}`;
     }
+    const r = this.db.prepare(
+      `SELECT COUNT(*) AS n, MAX(last_updated_at) AS t,
+                MAX(COALESCE(last_reinforced_at_seq, created_at_seq, 0)) AS s
+           FROM nodes WHERE valid_to IS NULL AND label IN (${labels.map(() => "?").join(",")})`
+    ).get(...labels);
+    return `${r.n}:${r.t ?? 0}:${r.s ?? 0}`;
   }
-}
-function clearRevisit(store2, nodeId, ts) {
-  const n = store2.getNode(nodeId);
-  if (!n) return;
-  const attrs = { ...n.attrs };
-  delete attrs["revisit"];
-  delete attrs["revisitReason"];
-  delete attrs["revisitSinceTs"];
-  store2.updateNode(nodeId, { attrs, lastUpdatedAt: ts });
-}
-function listNeedsRevisit(store2, asOf) {
-  return store2.nodesAsOfWhereTrue(asOf, "revisit").filter((n) => !n.attrs["retiredReason"]).map((n) => ({
-    id: n.id,
-    label: n.label,
-    description: n.description,
-    reason: String(n.attrs["revisitReason"] ?? "")
-  }));
-}
-
-// ../../packages/local-graph/src/credit.ts
-init_src2();
-var CREDIT_FAMILY = [
-  ...CAUSAL_EDGES,
-  ...RESOLUTION_EDGES,
-  ...JUSTIFICATION_EDGES
-];
-
-// ../../packages/local-graph/src/claims.ts
-init_src();
-init_src();
-
-// ../../packages/local-graph/src/crystallize.ts
-var LONG_TERM_SUPPORT = 2;
-var PERSISTENT_SUPPORT = 4;
-var PERSISTENT_CONFIDENCE = 0.85;
-var SCOPE_AXES = ["lang", "versionRange", "codebase", "regime"];
-function splittingAxis(a, b) {
-  for (const ax of SCOPE_AXES) {
-    if (a[ax] !== void 0 && b[ax] !== void 0 && a[ax] !== b[ax]) return ax;
+  /** Endpoints of edges TOUCHED since `ts` — created, re-seen, or CLOSED.
+   *  Closures matter as much as additions: a node that lost inflow is rank-dirty
+   *  while its own row never updated, so removal endpoints must seed the
+   *  incremental region or the stale inflow persists until the full backstop. */
+  edgeEndpointsTouchedSince(ts) {
+    const rows = this.db.prepare(
+      `SELECT from_id, to_id FROM edges
+         WHERE (valid_to IS NULL AND (created_at > :ts OR last_seen_at > :ts))
+            OR (valid_to IS NOT NULL AND valid_to > :ts)`
+    ).all({ ts });
+    return rows.map((r) => ({ from: r.from_id, to: r.to_id }));
   }
-  return null;
-}
-function support(n) {
-  return n.attrs["groundedSupport"] ?? 0;
-}
-function sourcesCount(n) {
-  const s = n.attrs["sources"];
-  return Array.isArray(s) ? s.length : 0;
-}
-function crystallize(store2, opts = { ts: 0 }) {
-  const claims = store2.findNodesByLabel("Claim");
-  const result = {
-    evaluated: claims.length,
-    promoted: [],
-    derived: [],
-    plural: [],
-    discriminators: [],
-    contested: []
-  };
-  for (const c of claims) {
-    const contradictions = store2.outEdges(c.id, ["CONTRADICTS"]).concat(store2.inEdges(c.id, ["CONTRADICTS"])).length;
-    const s = support(c) + Math.max(0, sourcesCount(c) - 1);
-    const f = contradictions;
-    const confidence = (1 + s) / (2 + s + f);
-    store2.updateNode(c.id, {
-      attrs: { ...c.attrs, confidence },
-      lastUpdatedAt: opts.ts
-    });
-    const sup = support(c);
-    let tier = c.memoryTier;
-    if (sup >= PERSISTENT_SUPPORT && confidence >= PERSISTENT_CONFIDENCE) tier = "persistent";
-    else if (sup >= LONG_TERM_SUPPORT) tier = "long-term";
-    if (tier !== c.memoryTier) {
-      store2.updateNode(c.id, { attrs: { ...store2.getNode(c.id).attrs }, memoryTier: tier, lastUpdatedAt: opts.ts });
-      result.promoted.push(c.id);
+  /** Lightweight out-edges for a SET of sources, chunked IN-lists — the region
+   *  assembly path for incremental PageRank (per-node outEdges() at region
+   *  scale re-creates the 106k-prepared-calls problem the batch scan solved). */
+  outEdgesForMany(ids) {
+    return this.edgesForMany(ids, "from_id");
+  }
+  inEdgesForMany(ids) {
+    return this.edgesForMany(ids, "to_id");
+  }
+  /** Stored pageRank for a SET of ids (live rows only — a closed id is simply
+   *  absent, which is how incremental region assembly drops dead endpoints). */
+  ranksForMany(ids) {
+    const out2 = /* @__PURE__ */ new Map();
+    const CHUNK = 400;
+    for (let i2 = 0; i2 < ids.length; i2 += CHUNK) {
+      const chunk = ids.slice(i2, i2 + CHUNK);
+      const placeholders = chunk.map(() => "?").join(", ");
+      const rows = this.db.prepare(
+        `SELECT id, page_rank FROM nodes WHERE id IN (${placeholders}) AND valid_to IS NULL`
+      ).all(...chunk);
+      for (const r of rows) out2.set(r.id, r.page_rank);
     }
+    return out2;
   }
-  const seenPair = /* @__PURE__ */ new Set();
-  for (const c of claims) {
-    for (const e of store2.outEdges(c.id, ["CONTRADICTS"])) {
-      const key = [e.from, e.to].sort().join("|");
-      if (seenPair.has(key)) continue;
-      seenPair.add(key);
-      const a = store2.getNode(e.from);
-      const b = store2.getNode(e.to);
-      if (!a || !b) continue;
-      const kind = mergeTruthKind(
-        a.attrs["truthKind"],
-        b.attrs["truthKind"]
-      );
-      if (kind === "objective") {
-        markBoth(store2, a, b, { needsDiscriminator: true }, opts.ts);
-        result.discriminators.push(a.id, b.id);
-        continue;
-      }
-      if (kind === "taste") {
-        markBoth(store2, a, b, { crystallized: "plural" }, opts.ts);
-        result.plural.push(a.id, b.id);
-        continue;
-      }
-      const axis = splittingAxis(
-        a.attrs["scope"] ?? {},
-        b.attrs["scope"] ?? {}
-      );
-      if (axis && support(a) > 0 && support(b) > 0) {
-        markBoth(store2, a, b, { crystallized: "derived", splitAxis: axis }, opts.ts);
-        result.derived.push(a.id, b.id);
-      } else if (axis) {
-        markBoth(store2, a, b, { crystallized: "hypothesis" }, opts.ts);
-      } else {
-        markBoth(
-          store2,
-          a,
-          b,
-          {
-            revisit: true,
-            revisitReason: "contested: contradictory contextual claim at the same scope, no splitting axis",
-            revisitSinceTs: opts.ts
-          },
-          opts.ts
-        );
-        result.contested.push(a.id, b.id);
-      }
+  /** The minimal row set the landmark sweep needs — landmark CANDIDATES
+   *  (Pattern/RootCause), everything currently flagged, and every
+   *  persistent-tier node (force-landmarks). A few thousand rows, so the
+   *  incremental path can refresh the GLOBAL landmark set without the 179k-row
+   *  scanLiveNodes materialization. */
+  landmarkSweepRows() {
+    const rows = this.db.prepare(
+      `SELECT id, label, page_rank, is_landmark, memory_tier, extraction_source FROM nodes
+         WHERE valid_to IS NULL
+           AND (memory_tier = 'persistent' OR is_landmark = 1 OR label IN ('Pattern', 'RootCause'))`
+    ).all();
+    return rows.map((r) => ({
+      id: r.id,
+      label: r.label,
+      pageRank: r.page_rank,
+      isLandmark: r.is_landmark === 1,
+      memoryTier: r.memory_tier,
+      extractionSource: r.extraction_source
+    }));
+  }
+  edgesForMany(ids, col) {
+    const out2 = [];
+    const CHUNK = 400;
+    for (let i2 = 0; i2 < ids.length; i2 += CHUNK) {
+      const chunk = ids.slice(i2, i2 + CHUNK);
+      const placeholders = chunk.map(() => "?").join(", ");
+      const rows = this.db.prepare(
+        `SELECT from_id, to_id, type FROM edges WHERE ${col} IN (${placeholders}) AND valid_to IS NULL`
+      ).all(...chunk);
+      for (const r of rows) out2.push({ from: r.from_id, to: r.to_id, type: r.type });
     }
+    return out2;
   }
-  return result;
-}
-function mergeTruthKind(a, b) {
-  if (a === "objective" || b === "objective") return "objective";
-  if (a === "contextual" || b === "contextual") return "contextual";
-  return "taste";
-}
-function markBoth(store2, a, b, patch, ts) {
-  for (const n of [a, b]) {
-    const fresh = store2.getNode(n.id);
-    store2.updateNode(n.id, { attrs: { ...fresh.attrs, ...patch }, lastUpdatedAt: ts });
+  checkpointWal() {
+    try {
+      const r = this.db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+      return r ?? null;
+    } catch {
+      return null;
+    }
   }
-}
-
-// ../../packages/local-graph/src/design-problem.ts
-init_src();
-init_src();
-
-// ../../packages/local-graph/src/problem-package-link.ts
-init_src();
-var NAME_SEPARATOR = /[@/\-._]/;
-var MIN_NAME_LEN = 3;
-function buildPackageIndex(store2) {
-  const idx = /* @__PURE__ */ new Map();
-  for (const n of store2.findNodesByLabel("Package")) {
-    const name2 = String(n.attrs["name"] ?? "").trim();
-    if (!name2) continue;
-    const key = name2.toLowerCase();
-    const prev = idx.get(key);
-    if (!prev || n.attrs["resolved"] === true && prev.attrs["resolved"] !== true) {
-      idx.set(key, n);
+  reviveReobserved(relPaths, workspaceId, since) {
+    let revived = 0;
+    const CHUNK = 400;
+    for (let i2 = 0; i2 < relPaths.length; i2 += CHUNK) {
+      const slice = relPaths.slice(i2, i2 + CHUNK);
+      if (slice.length === 0) continue;
+      const r = this.db.prepare(
+        `UPDATE nodes SET valid_to = NULL
+             WHERE valid_to IS NOT NULL
+               AND last_updated_at >= ?
+               AND json_extract(attrs_json, '$.workspaceId') = ?
+               AND json_extract(attrs_json, '$.relPath') IN (${slice.map(() => "?").join(",")})`
+      ).run(since, workspaceId, ...slice);
+      revived += Number(r.changes);
     }
+    if (revived > 0) this.mutations++;
+    return revived;
   }
-  return idx;
-}
-function escapeRe2(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function matchPackagesInText(text, index) {
-  const hay = text.toLowerCase();
-  const out2 = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const [key, node] of index) {
-    if (key.length < MIN_NAME_LEN) continue;
-    if (!hay.includes(key)) continue;
-    const esc2 = escapeRe2(key);
-    const bounded = new RegExp(`(?<![\\w@/.\\-])${esc2}(?![\\w])`);
-    if (!bounded.test(hay)) continue;
-    const verMatch = new RegExp(`${esc2}\\s*@?\\s*v?(\\d+(?:\\.\\d+){0,2})\\b`).exec(hay);
-    const hasSep = NAME_SEPARATOR.test(key);
-    if (!hasSep && !verMatch) continue;
-    if (seen.has(node.id)) continue;
-    seen.add(node.id);
-    out2.push(verMatch ? { node, version: verMatch[1] } : { node });
+  recentEdgeAttrCoverage(marker, attr, limit) {
+    const r = this.db.prepare(
+      `SELECT COUNT(*) AS total,
+                COALESCE(SUM(CASE WHEN json_extract(attrs_json, '$.' || ?) = 1 THEN 1 ELSE 0 END), 0) AS count
+           FROM (SELECT attrs_json FROM edges
+                  WHERE valid_to IS NULL AND attrs_json LIKE ?
+                  ORDER BY created_at DESC LIMIT ?)`
+    ).get(attr, `%${marker}%`, limit);
+    return { count: Number(r.count), total: Number(r.total) };
   }
-  return out2;
-}
-function linkProblemToPackages(store2, problemId, text, ts, index) {
-  const p = store2.getNode(problemId);
-  if (!p || p.label !== "Problem") return { linked: [] };
-  const idx = index ?? buildPackageIndex(store2);
-  if (idx.size === 0) return { linked: [] };
-  const already = new Set(store2.outEdges(problemId, ["DEPENDS_ON"]).map((e) => e.to));
-  const linked = [];
-  for (const { node, version: version3 } of matchPackagesInText(text, idx)) {
-    if (already.has(node.id)) continue;
-    addDependency(store2, {
-      fromId: problemId,
-      toId: node.id,
-      relation: "depends-on",
-      evidence: version3 ? `named in problem (@${version3})` : "named in problem statement",
-      ts,
-      extractionSource: "daemon-extracted"
-    });
-    already.add(node.id);
-    linked.push(node.id);
+  liveNodeIds(ids) {
+    const live = /* @__PURE__ */ new Set();
+    const CHUNK = 900;
+    for (let i2 = 0; i2 < ids.length; i2 += CHUNK) {
+      const slice = ids.slice(i2, i2 + CHUNK);
+      if (slice.length === 0) continue;
+      const rows = this.db.prepare(
+        `SELECT id FROM nodes WHERE valid_to IS NULL AND id IN (${slice.map(() => "?").join(",")})`
+      ).all(...slice);
+      for (const r of rows) live.add(r.id);
+    }
+    return live;
   }
-  return { linked };
-}
-function problemText(store2, p) {
-  const parts2 = [p.description];
-  for (const e of store2.outEdges(p.id, ["CAUSED_BY"])) {
-    const c = store2.getNode(e.to);
-    if (c) parts2.push(c.description);
+  /**
+   * Live edges WITH their endpoint labels and ids, resolved in ONE join.
+   *
+   * The ontology sweep needs (id, type, fromLabel, toLabel) for every live edge.
+   * Doing that as `scanLiveEdges()` + two `getNode()` calls is 2N node reads —
+   * 550,000 on this store — and each one deserializes the node's embedding blob.
+   * Measured: the sweep did not finish in 10 minutes. As a single join it is one
+   * query over an index-covered scan. Labels only; nothing here touches embeddings.
+   */
+  scanLiveEdgeRows() {
+    const rows = this.db.prepare(
+      `SELECT e.id, e.from_id, e.to_id, e.type, a.label AS from_label, b.label AS to_label
+         FROM edges e
+         LEFT JOIN nodes a ON a.id = e.from_id AND a.valid_to IS NULL
+         LEFT JOIN nodes b ON b.id = e.to_id   AND b.valid_to IS NULL
+         WHERE e.valid_to IS NULL`
+    ).all();
+    return rows.map((r) => ({
+      id: r.id,
+      from: r.from_id,
+      to: r.to_id,
+      type: r.type,
+      fromLabel: r.from_label ?? void 0,
+      toLabel: r.to_label ?? void 0
+    }));
   }
-  return parts2.join(" \n ");
-}
-function backfillProblemPackageLinks(store2, ts) {
-  const report = { problems: 0, edges: 0 };
-  const idx = buildPackageIndex(store2);
-  if (idx.size === 0) return report;
-  for (const p of store2.findNodesByLabel("Problem")) {
-    if (p.attrs["resolvedAs"] === "false_positive") continue;
-    const { linked } = linkProblemToPackages(store2, p.id, problemText(store2, p), ts, idx);
-    if (linked.length > 0) {
-      report.problems++;
-      report.edges += linked.length;
+  /** 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;
   }
-  return report;
-}
-function langNodeId(name2) {
-  return `lang:${name2.trim().toLowerCase()}`;
-}
-function specToPackageName(spec) {
-  const s = spec.trim();
-  if (!s || s.startsWith(".") || s.startsWith("/") || s.startsWith("node:")) return null;
-  const parts2 = s.split("/");
-  return (s.startsWith("@") ? parts2.slice(0, 2).join("/") : parts2[0]).toLowerCase();
-}
-function mergeContextEdge(store2, from, to, type, ts) {
-  store2.mergeEdge({
-    id: `edge_${digest({ from, type, to })}`.slice(0, 24),
-    from,
-    to,
-    type,
-    confidence: 0.4,
-    extractionSource: "daemon-extracted",
-    createdAt: ts,
-    lastSeenAt: ts,
-    navSuccesses: 0,
-    navFailures: 0,
-    attrs: { provisional: true, structural: true }
-  });
-}
-function deriveContextFromAnchors(store2, problemId, ts, pkgIndex) {
-  const report = { languages: [], packages: [] };
-  const p = store2.getNode(problemId);
-  if (!p || p.label !== "Problem" && p.label !== "Vulnerability") return report;
-  const files = store2.outEdges(problemId, ["ANCHORED_AT"]).map((e) => store2.getNode(e.to)).filter((n) => !!n && n.label === "File");
-  if (files.length === 0) return report;
-  const idx = pkgIndex ?? buildPackageIndex(store2);
-  const haveLang = new Set(store2.outEdges(problemId, ["OCCURS_IN"]).map((e) => e.to));
-  const havePkg = new Set(store2.outEdges(problemId, ["DEPENDS_ON"]).map((e) => e.to));
-  for (const file2 of files) {
-    const lang = String(file2.attrs["language"] ?? "").trim();
-    if (lang) {
-      const langId = langNodeId(lang);
-      if (!store2.getNode(langId)) {
-        store2.mergeNode({
-          id: langId,
-          label: "Language",
-          description: lang,
-          extractionConfidence: 1,
-          extractionSource: "daemon-extracted",
-          embedding: [],
-          cumulativeSurprise: 0,
-          peakSurprise: 0,
-          cumulativeHits: 0,
-          lastUpdatedAt: ts,
-          createdAt: ts,
-          memoryTier: "short-term",
-          pageRank: 0,
-          isLandmark: false,
-          community: null,
-          stability: "stable",
-          attrs: { name: lang, workspaceId: file2.attrs["workspaceId"] }
-        });
-      }
-      if (!haveLang.has(langId)) {
-        mergeContextEdge(store2, problemId, langId, "OCCURS_IN", ts);
-        haveLang.add(langId);
-        report.languages.push(langId);
-      }
-    }
-    for (const e of store2.outEdges(file2.id, ["IMPORTS"])) {
-      const mod = store2.getNode(e.to);
-      if (!mod) continue;
-      const name2 = specToPackageName(mod.description);
-      if (!name2) continue;
-      const pkg = idx.get(name2);
-      if (!pkg || havePkg.has(pkg.id)) continue;
-      addDependency(store2, {
-        fromId: problemId,
-        toId: pkg.id,
-        relation: "depends-on",
-        evidence: "imported by the anchored code",
-        ts,
-        extractionSource: "daemon-extracted"
-      });
-      havePkg.add(pkg.id);
-      report.packages.push(pkg.id);
+  nodesByRelPath(relPaths) {
+    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})`
+    ).all(...relPaths);
+    return rows.map(rowToNode);
+  }
+  findLiveNodesByAttr(label, attrPath, value) {
+    if (!/^[A-Za-z0-9_]+(\.[A-Za-z0-9_]+)*$/.test(attrPath)) throw new Error(`invalid attr path: ${attrPath}`);
+    const rows = this.db.prepare(
+      `SELECT * FROM nodes WHERE json_extract(attrs_json, '$.${attrPath}') = ? AND valid_to IS NULL AND label = ?`
+    ).all(value, label);
+    return rows.map(rowToNode);
+  }
+  // ── Bi-temporal versioning ───────────────────────────────────────────
+  // NOTE: the adapter's transaction() is non-reentrant (raw BEGIN/COMMIT), and
+  // the indexer calls freezeNode inside its own store.transaction(). So this
+  // method does NOT open a transaction — callers needing atomicity wrap it.
+  freezeNode(liveId, t) {
+    const live = this.getNode(liveId);
+    if (!live) return null;
+    const version3 = live.version ?? 1;
+    const frozenId = `${liveId}@v${version3}`;
+    if (this.getNode(frozenId)) {
+      this.stmts.advanceLive.run({ live_id: liveId, t });
+      return frozenId;
     }
+    this.stmts.freezeCopy.run({ frozen_id: frozenId, live_id: liveId, t });
+    this.mergeEdge({
+      id: `edge_superseded_${frozenId}`,
+      from: frozenId,
+      to: liveId,
+      type: "SUPERSEDED_BY",
+      confidence: 1,
+      extractionSource: "daemon-extracted",
+      createdAt: t,
+      lastSeenAt: t,
+      navSuccesses: 0,
+      navFailures: 0,
+      validFrom: t,
+      validTo: null,
+      attrs: {}
+    });
+    this.stmts.advanceLive.run({ live_id: liveId, t });
+    return frozenId;
   }
-  return report;
-}
-function backfillProblemContext(store2, ts) {
-  const report = { problems: 0, edges: 0 };
-  const idx = buildPackageIndex(store2);
-  for (const p of store2.findNodesByLabel("Problem")) {
-    if (p.attrs["resolvedAs"] === "false_positive") continue;
-    const r = deriveContextFromAnchors(store2, p.id, ts, idx);
-    const n = r.languages.length + r.packages.length;
-    if (n > 0) {
-      report.problems++;
-      report.edges += n;
-    }
+  closeNode(id, t) {
+    this.stmts.closeNode.run({ id, t });
   }
-  return report;
+  closeEdge(id, t) {
+    this.stmts.closeEdge.run({ id, t });
+  }
+  nodeHistory(logicalId) {
+    const rows = this.stmts.nodeHistory.all(logicalId);
+    return rows.map(rowToNode);
+  }
+  nodesAsOf(t) {
+    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);
+  }
+  transaction(fn) {
+    return this.db.transaction(fn);
+  }
+  close() {
+    this.db.close();
+  }
+};
+function openGraphStore(opts) {
+  return new SqliteGraphStore(opts);
 }
 
-// ../../packages/local-graph/src/design-problem.ts
+// ../../packages/local-graph/src/traversal.ts
 init_src2();
-
-// ../../packages/local-graph/src/problem-dedup.ts
-init_src();
-init_src();
-var REDIRECT_EDGES = [
-  "CAUSED_BY",
-  "SOLVED_BY",
-  "FIXED_BY",
-  "ANCHORED_AT",
-  "MANIFESTED_IN",
-  "EVIDENCED_BY"
+var MAX_EDGE_WEIGHT = Math.max(...Object.values(EDGE_WEIGHT));
+var CAUSAL_FAMILY = [
+  ...CAUSAL_EDGES,
+  ...RESOLUTION_EDGES
 ];
-function corroborations(n) {
-  return Number(n.attrs["corroborations"] ?? 0);
-}
-function overlap(a, b) {
-  if (a.size === 0 || b.size === 0) return 0;
-  let inter = 0;
-  for (const x of a) if (b.has(x)) inter++;
-  return inter / Math.min(a.size, b.size);
-}
-function mergeDuplicateProblems(store2, opts) {
-  const minOverlap = opts.minOverlap ?? 0.85;
-  const minTokens = opts.minTokens ?? 4;
-  const report = { clusters: 0, merged: 0 };
-  const open = store2.findNodesByLabel("Problem").filter((p) => p.attrs["resolvedAt"] == null && p.attrs["mergedInto"] === void 0);
-  const tokens = /* @__PURE__ */ new Map();
-  for (const p of open) tokens.set(p.id, new Set(retrievalTokens(p.description)));
-  const consumed = /* @__PURE__ */ new Set();
-  store2.transaction(() => {
-    for (let i2 = 0; i2 < open.length; i2++) {
-      const a = open[i2];
-      if (consumed.has(a.id)) continue;
-      const cluster = [a];
-      const ta = tokens.get(a.id);
-      for (let j = i2 + 1; j < open.length; j++) {
-        const b = open[j];
-        if (consumed.has(b.id)) continue;
-        const tb = tokens.get(b.id);
-        if (Math.min(ta.size, tb.size) < minTokens) continue;
-        if (isConstraintProblem(a) !== isConstraintProblem(b)) continue;
-        if (overlap(ta, tb) >= minOverlap) {
-          cluster.push(b);
-          consumed.add(b.id);
-        }
-      }
-      if (cluster.length < 2) continue;
-      report.clusters++;
-      cluster.sort((x, y) => corroborations(y) - corroborations(x) || x.createdAt - y.createdAt);
-      const survivor = cluster[0];
-      for (const dup of cluster.slice(1)) {
-        foldDuplicateProblem(store2, dup, survivor, opts.ts);
-        report.merged++;
-      }
-    }
-  });
-  return report;
-}
-function foldDuplicateProblem(store2, dup, survivor, ts) {
-  const surv = store2.getNode(survivor.id);
-  if (!surv) return;
-  const sources = new Set(surv.attrs["sources"] ?? []);
-  for (const s of dup.attrs["sources"] ?? []) sources.add(s);
-  const dupSeq = dup.attrs["createdAtSeq"] ?? store2.currentIngestSeq();
-  const exposure = priorExposure(store2, survivor.id, dupSeq);
-  const expField = `reinforce${exposure[0].toUpperCase()}${exposure.slice(1)}Count`;
-  store2.updateNode(survivor.id, {
-    attrs: {
-      ...surv.attrs,
-      sources: [...sources],
-      corroborations: corroborations(surv) + corroborations(dup) + 1,
-      [expField]: (surv.attrs[expField] ?? 0) + 1,
-      lastReinforceExposure: exposure
-    },
-    cumulativeHits: (surv.cumulativeHits ?? 0) + (dup.cumulativeHits ?? 0),
-    lastUpdatedAt: ts
-  });
-  for (const e of store2.outEdges(dup.id, REDIRECT_EDGES)) {
-    if (e.to === survivor.id) continue;
-    const id = `edge_${digest({ from: survivor.id, type: e.type, to: e.to })}`.slice(0, 24);
-    if (store2.getEdge(id)) continue;
-    const redirected = {
-      ...e,
-      id,
-      from: survivor.id,
-      createdAt: ts,
-      lastSeenAt: ts
-    };
-    store2.mergeEdge(redirected);
-  }
-  store2.updateNode(dup.id, {
-    attrs: { ...dup.attrs, mergedInto: survivor.id, resolvedAs: "duplicate", resolvedAt: ts },
-    lastUpdatedAt: ts
-  });
-  store2.closeNode(dup.id, ts);
-}
 
-// ../../packages/local-graph/src/design-problem.ts
+// ../../packages/local-graph/src/justification.ts
 init_src();
-function isConstraintProblem(node) {
-  return node.attrs["kind"] === "constraint";
-}
-var RECURRENCE_DEBOUNCE_MS = 60 * 60 * 1e3;
-function resolveFileNode(store2, path, workspaceId) {
-  const want = path.trim().replace(/^\.?\//, "");
-  for (const n of store2.findNodesByLabel("File")) {
-    if (n.attrs["workspaceId"] && n.attrs["workspaceId"] !== workspaceId) continue;
-    if (n.attrs["relPath"] === want || n.description === want) return n;
-  }
-  return null;
-}
-var CITABLE_PRIOR_LABELS = /* @__PURE__ */ new Set([
-  "Solution",
-  "RootCause",
-  "Pattern",
-  "Technique",
-  "AntiPattern"
-]);
-function isAutoMinted(n) {
-  return isEditPlaceholderSolution(n);
-}
-function priorsForFile(store2, relPath) {
-  const want = relPath.trim().replace(/^\.?\//, "");
-  let file2 = null;
-  for (const n of store2.findNodesByLabel("File")) {
-    if (n.description === want || n.attrs["relPath"] === want) {
-      file2 = n;
-      break;
-    }
-  }
-  if (!file2) return null;
-  const openProblems = [];
-  const constraints = [];
-  const resolvedProblems = [];
-  const seenProblem = /* @__PURE__ */ new Set();
-  const related = /* @__PURE__ */ new Map();
-  const anchorEdges = [
-    ...store2.inEdges(file2.id, ["ANCHORED_AT"]),
-    ...store2.outEdges(file2.id, ["DEFINES"]).flatMap((d) => store2.inEdges(d.to, ["ANCHORED_AT"]))
-  ];
-  for (const e of anchorEdges) {
-    const n = store2.getNode(e.from);
-    if (!n) continue;
-    if (n.label === "Problem" || n.label === "Vulnerability") {
-      if (seenProblem.has(n.id)) continue;
-      seenProblem.add(n.id);
-      if (!n.attrs["resolvedAt"]) {
-        (isConstraintProblem(n) ? constraints : openProblems).push(n);
-      } else if (n.attrs["resolvedAs"] == null && n.attrs["mergedInto"] === void 0 && e.attrs?.["anchorProvenance"] !== "legacy") {
-        resolvedProblems.push(n);
-      }
-    } else if (CITABLE_PRIOR_LABELS.has(n.label) && !isAutoMinted(n)) {
-      related.set(n.id, n);
-    }
-  }
-  const solutionsByProblem = /* @__PURE__ */ new Map();
-  for (const p of [...openProblems, ...constraints, ...resolvedProblems]) {
-    for (const e of store2.outEdges(p.id, ["SOLVED_BY", "CAUSED_BY", "INSTANCE_OF"])) {
-      const n = store2.getNode(e.to);
-      if (n && CITABLE_PRIOR_LABELS.has(n.label) && !isAutoMinted(n)) related.set(n.id, n);
-      if (n && n.label === "Solution" && e.type === "SOLVED_BY" && !isAutoMinted(n)) {
-        const list = solutionsByProblem.get(p.id) ?? [];
-        if (!list.some((s) => s.id === n.id)) list.push(n);
-        solutionsByProblem.set(p.id, list);
-      }
-    }
-  }
-  if (openProblems.length === 0 && constraints.length === 0 && resolvedProblems.length === 0 && related.size === 0)
-    return null;
-  const recentFirst = (a, b) => (b.lastUpdatedAt ?? 0) - (a.lastUpdatedAt ?? 0);
-  openProblems.sort(recentFirst);
-  constraints.sort(recentFirst);
-  resolvedProblems.sort(
-    (a, b) => Number(b.attrs["resolvedAt"] ?? 0) - Number(a.attrs["resolvedAt"] ?? 0)
-  );
-  return {
-    file: file2,
-    openProblems,
-    constraints,
-    resolvedProblems,
-    related: [...related.values()],
-    solutionsByProblem
+init_src2();
+function addDependency(store2, opts) {
+  const id = digest({ from: opts.fromId, type: "DEPENDS_ON", to: opts.toId });
+  const attrs = { relation: opts.relation };
+  if (opts.introduced !== void 0) attrs.introduced = opts.introduced;
+  if (opts.fixed !== void 0) attrs.fixed = opts.fixed;
+  if (opts.evidence !== void 0) attrs.evidence = opts.evidence;
+  const edge = {
+    id,
+    from: opts.fromId,
+    to: opts.toId,
+    type: "DEPENDS_ON",
+    confidence: 1,
+    extractionSource: opts.extractionSource ?? "agent-observed",
+    createdAt: opts.ts,
+    lastSeenAt: opts.ts,
+    navSuccesses: 0,
+    navFailures: 0,
+    attrs
   };
+  store2.mergeEdge(edge);
+  return edge;
 }
-function anchorProblemToWorkingFile(store2, problemId, relPath, workspaceId, ts, provenance = "edited", opts = {}) {
-  const p = store2.getNode(problemId);
-  if (!p || p.label !== "Problem" && p.label !== "Vulnerability") return false;
-  if (p.label === "Vulnerability" && provenance !== "witnessed") return false;
-  if (!isAnchorableCodePath(relPath)) return false;
-  const file2 = resolveFileNode(store2, relPath, workspaceId);
-  if (!file2) return false;
-  const already = new Set(store2.outEdges(problemId, ["ANCHORED_AT"]).map((e) => e.to));
-  const confidence = provenance === "witnessed" ? 0.4 : 0.3;
-  if (!already.has(file2.id)) {
-    store2.mergeEdge({
-      id: `edge_${digest({ from: problemId, type: "ANCHORED_AT", to: file2.id })}`.slice(0, 24),
-      from: problemId,
-      to: file2.id,
-      type: "ANCHORED_AT",
-      confidence,
-      extractionSource: "agent-observed",
-      createdAt: ts,
-      lastSeenAt: ts,
-      navSuccesses: 0,
-      navFailures: 0,
-      attrs: { provisional: true, captureTime: true, anchorProvenance: provenance }
-    });
+function markRevisit(store2, node, reason, ts, answeredWhen) {
+  const fresh = store2.getNode(node.id) ?? node;
+  if (fresh.validTo != null || fresh.attrs["retiredReason"]) return;
+  store2.updateNode(node.id, {
+    attrs: {
+      ...fresh.attrs,
+      revisit: true,
+      revisitReason: reason,
+      revisitSinceTs: ts,
+      revisitAnsweredWhen: answeredWhen
+    },
+    lastUpdatedAt: ts
+  });
+}
+var LEGACY_AUTO_CLOSE_ASK = "auto-closed off a pre-provenance anchor";
+var KNOWN_CONDITIONS = {
+  parentProblemOpen: true,
+  dependentStale: true
+};
+function isRevisitCondition(v) {
+  return typeof v === "string" && Object.prototype.hasOwnProperty.call(KNOWN_CONDITIONS, v);
+}
+function conditionOf(node) {
+  const explicit = node.attrs["revisitAnsweredWhen"];
+  if (isRevisitCondition(explicit)) return explicit;
+  if (String(node.attrs["revisitReason"] ?? "").startsWith(LEGACY_AUTO_CLOSE_ASK)) {
+    return "parentProblemOpen";
   }
-  if (opts.line !== void 0 && opts.fileText !== void 0) {
-    const sym = resolveEnclosingSymbol(store2, file2.id, opts.line, opts.fileText);
-    if (sym && !already.has(sym.id)) {
-      store2.mergeEdge({
-        id: `edge_${digest({ from: problemId, type: "ANCHORED_AT", to: sym.id })}`.slice(0, 24),
-        from: problemId,
-        to: sym.id,
-        type: "ANCHORED_AT",
-        confidence,
-        extractionSource: "agent-observed",
-        createdAt: ts,
-        lastSeenAt: ts,
-        navSuccesses: 0,
-        navFailures: 0,
-        attrs: {
-          provisional: true,
-          captureTime: true,
-          anchorProvenance: provenance,
-          anchorLine: opts.line,
-          enclosingSymbol: true,
-          // PJ-anchor-version: WHICH version of the symbol this was witnessed
-          // against. `bodyHash` is the indexer's 16-hex sha256 of the body;
-          // `headSha` is the checkout's HEAD at capture. Both opaque, both
-          // cross the membrane on the anchor edge, and a teammate's reanchor
-          // compares the hash with their own symbol to tell "current" from
-          // "pre-change" — the branch hazard where a fix witnessed on feat/x
-          // would otherwise read as a fact about the unchanged symbol on dev.
-          ...typeof sym.attrs["bodyHash"] === "string" ? { symbolContentHash: sym.attrs["bodyHash"] } : {},
-          ...opts.headSha ? { observedAtCommit: opts.headSha } : {}
-        }
-      });
+  return void 0;
+}
+function clearAnsweredRevisits(store2, ts) {
+  const report = { cleared: 0, standing: 0 };
+  for (const label of SEMANTIC_NODE_LABELS) {
+    for (const node of store2.findNodesByLabel(label)) {
+      if (node.attrs["revisit"] !== true) continue;
+      const condition = conditionOf(node);
+      if (condition === void 0 || !isRevisitAnswered(store2, node, condition)) {
+        report.standing++;
+        continue;
+      }
+      clearRevisit(store2, node.id, ts);
+      report.cleared++;
     }
   }
-  return true;
+  return report;
 }
-var ENCLOSING_SYMBOL_KINDS = /* @__PURE__ */ new Set([
-  "Function",
-  "Class",
-  "Method",
-  "Module",
-  "Interface",
-  "Const",
-  "Enum",
-  "TypeAlias",
-  "Namespace",
-  "Property"
-]);
-var ENCLOSING_WALK_DEPTH = 8;
-function resolveEnclosingSymbol(store2, fileId, line, fileText) {
-  if (!Number.isFinite(line) || line < 1) return null;
-  const row = Math.floor(line) - 1;
-  const lineStarts = [0];
-  for (let i2 = 0; i2 < fileText.length; i2++) if (fileText.charCodeAt(i2) === 10) lineStarts.push(i2 + 1);
-  const rowOf = (index) => {
-    let lo = 0;
-    let hi = lineStarts.length - 1;
-    while (lo < hi) {
-      const mid = lo + hi + 1 >> 1;
-      if (lineStarts[mid] <= index) lo = mid;
-      else hi = mid - 1;
+function isRevisitAnswered(store2, node, condition) {
+  switch (condition) {
+    case "parentProblemOpen": {
+      const parents = store2.inEdges(node.id, ["SOLVED_BY"]).map((e) => store2.getNode(e.from)).filter((n) => n !== null && n.validTo == null);
+      return parents.every((p) => p.attrs["resolvedAt"] == null);
     }
-    return lo;
-  };
-  let best = null;
-  let bestStart = -1;
-  let bestSpan = Number.POSITIVE_INFINITY;
-  const seen = /* @__PURE__ */ new Set([fileId]);
-  let frontier = [fileId];
-  for (let depth = 0; depth < ENCLOSING_WALK_DEPTH && frontier.length > 0; depth++) {
-    const next = [];
-    for (const id of frontier) {
-      for (const e of store2.outEdges(id, ["DEFINES"])) {
-        if (seen.has(e.to)) continue;
-        seen.add(e.to);
-        const n = store2.getNode(e.to);
-        if (!n) continue;
-        next.push(n.id);
-        if (!ENCLOSING_SYMBOL_KINDS.has(n.label)) continue;
-        const startRow = n.attrs["startRow"];
-        const startByte = n.attrs["startByte"];
-        const endByte = n.attrs["endByte"];
-        if (typeof startRow !== "number" || typeof startByte !== "number" || typeof endByte !== "number") continue;
-        if (startRow < 0 || endByte < startByte) continue;
-        const endRow = rowOf(Math.max(startByte, Math.min(endByte, fileText.length) - 1));
-        if (row < startRow || row > endRow) continue;
-        const span = endByte - startByte;
-        if (startRow > bestStart || startRow === bestStart && span < bestSpan) {
-          best = n;
-          bestStart = startRow;
-          bestSpan = span;
-        }
-      }
+    case "dependentStale": {
+      const since = Number(node.attrs["revisitSinceTs"] ?? 0);
+      return since > 0 && node.lastUpdatedAt > since;
     }
-    frontier = next;
   }
-  return best;
-}
-function recordAnchorHint(store2, problemId, relPath, provenance, ts) {
-  const p = store2.getNode(problemId);
-  if (!p || p.label !== "Problem") return false;
-  if (p.attrs["anchorHint"]) return false;
-  store2.updateNode(problemId, {
-    attrs: { ...p.attrs, anchorHint: { path: relPath, provenance, ts } }
-  });
-  return true;
 }
-function openAnchorHint(p) {
-  const h = p.attrs["anchorHint"];
-  if (!h || typeof h.path !== "string" || h.upgradedAt) return null;
-  return { path: h.path, ts: typeof h.ts === "number" ? h.ts : 0 };
+function clearRevisit(store2, nodeId, ts) {
+  const n = store2.getNode(nodeId);
+  if (!n) return;
+  const attrs = { ...n.attrs };
+  delete attrs["revisit"];
+  delete attrs["revisitReason"];
+  delete attrs["revisitSinceTs"];
+  store2.updateNode(nodeId, { attrs, lastUpdatedAt: ts });
 }
-function consumeAnchorHint(store2, p, ts) {
-  const hint = p.attrs["anchorHint"];
-  store2.updateNode(p.id, { attrs: { ...p.attrs, anchorHint: { ...hint, upgradedAt: ts } } });
-  deriveContextFromAnchors(store2, p.id, ts);
+function listNeedsRevisit(store2, asOf) {
+  return store2.nodesAsOfWhereTrue(asOf, "revisit").filter((n) => !n.attrs["retiredReason"]).map((n) => ({
+    id: n.id,
+    label: n.label,
+    description: n.description,
+    reason: String(n.attrs["revisitReason"] ?? "")
+  }));
 }
-function upgradeAnchorHints(store2, workspaceId, ts) {
-  let upgraded = 0;
-  let standing = 0;
-  let unresolvable = 0;
-  let blocked = 0;
-  const filesByPath = /* @__PURE__ */ new Map();
-  for (const f of store2.findNodesByLabel("File")) {
-    if (f.attrs["workspaceId"] && f.attrs["workspaceId"] !== workspaceId) continue;
-    const rel = typeof f.attrs["relPath"] === "string" ? f.attrs["relPath"] : f.description;
-    if (rel && !filesByPath.has(rel)) filesByPath.set(rel, f);
-  }
-  for (const p of store2.findNodesByLabel("Problem")) {
-    if (p.validTo != null || p.attrs["resolvedAt"]) continue;
-    const hint = openAnchorHint(p);
-    if (!hint) continue;
-    const file2 = filesByPath.get(hint.path.trim().replace(/^\.?\//, ""));
-    if (!file2 || !isAnchorableCodePath(hint.path)) {
-      unresolvable++;
-      continue;
-    }
-    standing++;
-    const changedAt = Number(file2.attrs["contentChangedAt"] ?? 0);
-    if (changedAt <= hint.ts) continue;
-    if (anchorProblemToWorkingFile(store2, p.id, hint.path, workspaceId, ts, "hint-confirmed")) {
-      consumeAnchorHint(store2, p, ts);
-      upgraded++;
-      standing--;
-    } else {
-      blocked++;
-    }
+
+// ../../packages/local-graph/src/credit.ts
+init_src2();
+var CREDIT_FAMILY = [
+  ...CAUSAL_EDGES,
+  ...RESOLUTION_EDGES,
+  ...JUSTIFICATION_EDGES
+];
+
+// ../../packages/local-graph/src/claims.ts
+init_src();
+init_src();
+
+// ../../packages/local-graph/src/crystallize.ts
+var LONG_TERM_SUPPORT = 2;
+var PERSISTENT_SUPPORT = 4;
+var PERSISTENT_CONFIDENCE = 0.85;
+var SCOPE_AXES = ["lang", "versionRange", "codebase", "regime"];
+function splittingAxis(a, b) {
+  for (const ax of SCOPE_AXES) {
+    if (a[ax] !== void 0 && b[ax] !== void 0 && a[ax] !== b[ax]) return ax;
   }
-  return { upgraded, standing, unresolvable, blocked };
+  return null;
+}
+function support(n) {
+  return n.attrs["groundedSupport"] ?? 0;
 }
-function reopenAutoClosedProblems(store2, t) {
-  const report = { reopened: 0, alreadySuspect: 0, agentDescribed: 0 };
-  for (const p of store2.findNodesByLabel("Problem")) {
-    if (p.attrs["resolvedAt"] == null) continue;
-    if (p.attrs["resolvedAs"] != null) continue;
-    if (p.attrs["mergedInto"] !== void 0) continue;
-    if (p.attrs["resolutionWitnessed"] === true) {
-      report.agentDescribed++;
-      continue;
-    }
-    const sols = store2.outEdges(p.id, ["SOLVED_BY"]).map((e) => store2.getNode(e.to)).filter((n) => n !== null);
-    if (sols.length === 0 && p.attrs["retiredEditPlaceholder"] !== true) continue;
-    if (!sols.every((s) => String(s.description ?? "").startsWith(AUTO_MINT_PREFIX))) {
-      report.agentDescribed++;
-      continue;
+function sourcesCount(n) {
+  const s = n.attrs["sources"];
+  return Array.isArray(s) ? s.length : 0;
+}
+function crystallize(store2, opts = { ts: 0 }) {
+  const claims = store2.findNodesByLabel("Claim");
+  const result = {
+    evaluated: claims.length,
+    promoted: [],
+    derived: [],
+    plural: [],
+    discriminators: [],
+    contested: []
+  };
+  for (const c of claims) {
+    const contradictions = store2.outEdges(c.id, ["CONTRADICTS"]).concat(store2.inEdges(c.id, ["CONTRADICTS"])).length;
+    const s = support(c) + Math.max(0, sourcesCount(c) - 1);
+    const f = contradictions;
+    const confidence = (1 + s) / (2 + s + f);
+    store2.updateNode(c.id, {
+      attrs: { ...c.attrs, confidence },
+      lastUpdatedAt: opts.ts
+    });
+    const sup = support(c);
+    let tier = c.memoryTier;
+    if (sup >= PERSISTENT_SUPPORT && confidence >= PERSISTENT_CONFIDENCE) tier = "persistent";
+    else if (sup >= LONG_TERM_SUPPORT) tier = "long-term";
+    if (tier !== c.memoryTier) {
+      store2.updateNode(c.id, { attrs: { ...store2.getNode(c.id).attrs }, memoryTier: tier, lastUpdatedAt: opts.ts });
+      result.promoted.push(c.id);
     }
-    if (p.attrs["resolutionSuspect"] === true) report.alreadySuspect++;
-    const attrs = { ...p.attrs };
-    delete attrs["resolvedAt"];
-    attrs["reopenedFrom"] = "auto-close";
-    attrs["reopenedAt"] = t;
-    store2.updateNode(p.id, { attrs, lastUpdatedAt: t });
-    report.reopened++;
   }
-  return report;
-}
-function markFixCandidates(store2, t) {
-  let resolved = 0;
-  for (const p of store2.findNodesByLabel("Problem")) {
-    if (!p.id.startsWith("dprob_")) continue;
-    if (p.attrs["resolvedAt"]) continue;
-    if (isConstraintProblem(p)) continue;
-    let symName = "";
-    let symRelPath;
-    let edited = false;
-    const since = Math.max(p.createdAt, Number(p.attrs["fixCandidateClearedAt"] ?? 0));
-    for (const e of store2.outEdges(p.id, ["ANCHORED_AT"])) {
-      if (e.attrs?.["mention"] === true) continue;
-      if (e.attrs?.["anchorProvenance"] === "legacy") continue;
-      const sym = store2.getNode(e.to);
-      const changedAt = sym?.label === "File" ? Number(sym.attrs["contentChangedAt"] ?? 0) : sym?.lastUpdatedAt ?? 0;
-      if (sym && changedAt > since) {
-        edited = true;
-        symName = sym.description;
-        symRelPath = sym.attrs["relPath"] ?? void 0;
-        break;
+  const seenPair = /* @__PURE__ */ new Set();
+  for (const c of claims) {
+    for (const e of store2.outEdges(c.id, ["CONTRADICTS"])) {
+      const key = [e.from, e.to].sort().join("|");
+      if (seenPair.has(key)) continue;
+      seenPair.add(key);
+      const a = store2.getNode(e.from);
+      const b = store2.getNode(e.to);
+      if (!a || !b) continue;
+      const kind = mergeTruthKind(
+        a.attrs["truthKind"],
+        b.attrs["truthKind"]
+      );
+      if (kind === "objective") {
+        markBoth(store2, a, b, { needsDiscriminator: true }, opts.ts);
+        result.discriminators.push(a.id, b.id);
+        continue;
       }
-    }
-    if (!edited) continue;
-    if (p.attrs["fixCandidateAt"] !== void 0) continue;
-    if (store2.outEdges(p.id, ["SOLVED_BY"]).some((e) => {
-      const s = store2.getNode(e.to);
-      return s !== null && !String(s.description ?? "").startsWith(AUTO_MINT_PREFIX);
-    }))
-      continue;
-    store2.updateNode(p.id, {
-      attrs: {
-        ...p.attrs,
-        // The cue, kept as structured data so the render can name the file it is
-        // asking about. Deliberately NOT `resolvedAt` — this is a question.
-        fixCandidateAt: t,
-        fixCandidateSymbol: symName,
-        ...symRelPath ? { fixCandidateFile: symRelPath } : {},
-        // Snapshot the render-ledger counter so "shown since THIS ask" is
-        // measurable. `shownCount` is the node's LIFETIME count across every
-        // band, so comparing it raw would retire a fresh ask on a
-        // frequently-surfaced problem before anyone had seen the question once.
-        fixCandidateShownBase: Number(p.attrs["shownCount"] ?? 0)
+      if (kind === "taste") {
+        markBoth(store2, a, b, { crystallized: "plural" }, opts.ts);
+        result.plural.push(a.id, b.id);
+        continue;
+      }
+      const axis = splittingAxis(
+        a.attrs["scope"] ?? {},
+        b.attrs["scope"] ?? {}
+      );
+      if (axis && support(a) > 0 && support(b) > 0) {
+        markBoth(store2, a, b, { crystallized: "derived", splitAxis: axis }, opts.ts);
+        result.derived.push(a.id, b.id);
+      } else if (axis) {
+        markBoth(store2, a, b, { crystallized: "hypothesis" }, opts.ts);
+      } else {
+        markBoth(
+          store2,
+          a,
+          b,
+          {
+            revisit: true,
+            revisitReason: "contested: contradictory contextual claim at the same scope, no splitting axis",
+            revisitSinceTs: opts.ts
+          },
+          opts.ts
+        );
+        result.contested.push(a.id, b.id);
       }
-      // No `lastUpdatedAt`: raising a question is bookkeeping, not a new
-      // observation of the problem, and the passive block's recent-problems band
-      // sorts on that field (see clearSettledFixCandidates).
-    });
-    resolved++;
-  }
-  return resolved;
-}
-var FIX_CANDIDATE_ASK_LIMIT = 5;
-function clearSettledFixCandidates(store2, t) {
-  const report = { answered: 0, ignored: 0, unsubstantiated: 0, standing: 0 };
-  for (const p of store2.findNodesByLabel("Problem")) {
-    if (p.attrs["fixCandidateAt"] === void 0) continue;
-    const fileAnchors = store2.outEdges(p.id, ["ANCHORED_AT"]).filter((e) => e.attrs?.["mention"] !== true && e.attrs?.["anchorProvenance"] !== "legacy").map((e) => store2.getNode(e.to)).filter((n) => n !== null && n.label === "File");
-    const unsubstantiated = fileAnchors.length > 0 && fileAnchors.every((f) => f.attrs["contentChangedAt"] === void 0);
-    const answered = p.attrs["resolvedAt"] != null || store2.outEdges(p.id, ["SOLVED_BY"]).some((e) => {
-      const s = store2.getNode(e.to);
-      return s !== null && !String(s.description ?? "").startsWith(AUTO_MINT_PREFIX);
-    });
-    const base = Number(
-      p.attrs["fixCandidateShownBase"] ?? p.attrs["shownCount"] ?? 0
-    );
-    const shownSinceAsk = Number(p.attrs["shownCount"] ?? 0) - base;
-    const ignored = shownSinceAsk >= FIX_CANDIDATE_ASK_LIMIT;
-    if (!answered && !ignored && !unsubstantiated) {
-      report.standing++;
-      continue;
     }
-    const attrs = { ...p.attrs };
-    delete attrs["fixCandidateAt"];
-    delete attrs["fixCandidateSymbol"];
-    delete attrs["fixCandidateFile"];
-    attrs["fixCandidateClearedAt"] = t;
-    store2.updateNode(p.id, { attrs });
-    if (answered) report.answered++;
-    else if (ignored) report.ignored++;
-    else report.unsubstantiated++;
   }
-  return report;
+  return result;
 }
-function priorExposure(store2, nodeId, atSeq) {
-  const n = store2.getNode(nodeId);
-  if (!n || !n.attrs) return "unshown";
-  const shownSeq = n.attrs["lastShownAtSeq"];
-  if (shownSeq !== void 0 && shownSeq <= atSeq) return "shown";
-  const evictedSeq = n.attrs["lastEvictedAtSeq"];
-  if (evictedSeq !== void 0 && evictedSeq <= atSeq) return "evicted";
-  if ((n.attrs["evictedCount"] ?? 0) > 0) return "evicted";
-  return "unshown";
+function mergeTruthKind(a, b) {
+  if (a === "objective" || b === "objective") return "objective";
+  if (a === "contextual" || b === "contextual") return "contextual";
+  return "taste";
+}
+function markBoth(store2, a, b, patch, ts) {
+  for (const n of [a, b]) {
+    const fresh = store2.getNode(n.id);
+    store2.updateNode(n.id, { attrs: { ...fresh.attrs, ...patch }, lastUpdatedAt: ts });
+  }
 }
 
-// ../../packages/local-graph/src/intent.ts
+// ../../packages/local-graph/src/design-problem.ts
+init_src();
 init_src();
 
-// ../../packages/local-graph/src/anchor-backfill.ts
+// ../../packages/local-graph/src/problem-package-link.ts
 init_src();
-init_src2();
-function isLegacyAnchor(attrs) {
-  return attrs?.["captureTime"] === true && attrs["anchorProvenance"] === void 0;
+var NAME_SEPARATOR = /[@/\-._]/;
+var MIN_NAME_LEN = 3;
+function buildPackageIndex(store2) {
+  const idx = /* @__PURE__ */ new Map();
+  for (const n of store2.findNodesByLabel("Package")) {
+    const name2 = String(n.attrs["name"] ?? "").trim();
+    if (!name2) continue;
+    const key = name2.toLowerCase();
+    const prev = idx.get(key);
+    if (!prev || n.attrs["resolved"] === true && prev.attrs["resolved"] !== true) {
+      idx.set(key, n);
+    }
+  }
+  return idx;
+}
+function escapeRe2(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function matchPackagesInText(text, index) {
+  const hay = text.toLowerCase();
+  const out2 = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [key, node] of index) {
+    if (key.length < MIN_NAME_LEN) continue;
+    if (!hay.includes(key)) continue;
+    const esc2 = escapeRe2(key);
+    const bounded = new RegExp(`(?<![\\w@/.\\-])${esc2}(?![\\w])`);
+    if (!bounded.test(hay)) continue;
+    const verMatch = new RegExp(`${esc2}\\s*@?\\s*v?(\\d+(?:\\.\\d+){0,2})\\b`).exec(hay);
+    const hasSep = NAME_SEPARATOR.test(key);
+    if (!hasSep && !verMatch) continue;
+    if (seen.has(node.id)) continue;
+    seen.add(node.id);
+    out2.push(verMatch ? { node, version: verMatch[1] } : { node });
+  }
+  return out2;
+}
+function linkProblemToPackages(store2, problemId, text, ts, index) {
+  const p = store2.getNode(problemId);
+  if (!p || p.label !== "Problem") return { linked: [] };
+  const idx = index ?? buildPackageIndex(store2);
+  if (idx.size === 0) return { linked: [] };
+  const already = new Set(store2.outEdges(problemId, ["DEPENDS_ON"]).map((e) => e.to));
+  const linked = [];
+  for (const { node, version: version3 } of matchPackagesInText(text, idx)) {
+    if (already.has(node.id)) continue;
+    addDependency(store2, {
+      fromId: problemId,
+      toId: node.id,
+      relation: "depends-on",
+      evidence: version3 ? `named in problem (@${version3})` : "named in problem statement",
+      ts,
+      extractionSource: "daemon-extracted"
+    });
+    already.add(node.id);
+    linked.push(node.id);
+  }
+  return { linked };
 }
-var STATEMENT_PATH_RE = new RegExp(
-  String.raw`(?:[\w.+-]+\/)+[\w.+-]+\.(?:${anchorableExtensionAlternation()})`,
-  "g"
-);
-function filePathResolver(store2) {
-  const byPath = /* @__PURE__ */ new Map();
-  for (const f of store2.findNodesByLabel("File")) {
-    const path = String(f.attrs["relPath"] ?? f.description ?? "");
-    if (path) byPath.set(path, { id: f.id, path });
+function problemText(store2, p) {
+  const parts2 = [p.description];
+  for (const e of store2.outEdges(p.id, ["CAUSED_BY"])) {
+    const c = store2.getNode(e.to);
+    if (c) parts2.push(c.description);
   }
-  return (named) => {
-    const exact = byPath.get(named);
-    if (exact) return exact;
-    const hits = [...byPath.values()].filter(
-      (f) => f.path.endsWith(`/${named}`) || named.endsWith(`/${f.path}`)
-    );
-    return hits.length === 1 ? hits[0] : null;
-  };
+  return parts2.join(" \n ");
 }
-function statementTarget(statement, resolvePath) {
-  for (const m of statement.matchAll(STATEMENT_PATH_RE)) {
-    const f = resolvePath(m[0]);
-    if (f) return f;
+function backfillProblemPackageLinks(store2, ts) {
+  const report = { problems: 0, edges: 0 };
+  const idx = buildPackageIndex(store2);
+  if (idx.size === 0) return report;
+  for (const p of store2.findNodesByLabel("Problem")) {
+    if (p.attrs["resolvedAs"] === "false_positive") continue;
+    const { linked } = linkProblemToPackages(store2, p.id, problemText(store2, p), ts, idx);
+    if (linked.length > 0) {
+      report.problems++;
+      report.edges += linked.length;
+    }
   }
-  return null;
+  return report;
 }
-function restatedAnchor(problemId, fileId, restatedFrom, ts) {
-  return {
-    id: `edge_${digest({ from: problemId, type: "ANCHORED_AT", to: fileId })}`.slice(0, 24),
-    from: problemId,
-    to: fileId,
-    type: "ANCHORED_AT",
-    // Same confidence a capture-time anchor enters at: the source is the
-    // agent's own statement either way, only the moment of reading differs.
+function langNodeId(name2) {
+  return `lang:${name2.trim().toLowerCase()}`;
+}
+function specToPackageName(spec) {
+  const s = spec.trim();
+  if (!s || s.startsWith(".") || s.startsWith("/") || s.startsWith("node:")) return null;
+  const parts2 = s.split("/");
+  return (s.startsWith("@") ? parts2.slice(0, 2).join("/") : parts2[0]).toLowerCase();
+}
+function mergeContextEdge(store2, from, to, type, ts) {
+  store2.mergeEdge({
+    id: `edge_${digest({ from, type, to })}`.slice(0, 24),
+    from,
+    to,
+    type,
     confidence: 0.4,
-    extractionSource: "agent-observed",
+    extractionSource: "daemon-extracted",
     createdAt: ts,
     lastSeenAt: ts,
     navSuccesses: 0,
     navFailures: 0,
-    attrs: { anchorProvenance: "restated", restatedFrom, restatedAt: ts }
-  };
+    attrs: { provisional: true, structural: true }
+  });
 }
-function repairLegacyAnchorsFromStatement(store2, ts) {
-  const report = {
-    repaired: [],
-    retiredGuesses: 0,
-    noPathNamed: 0,
-    pathUnknown: 0,
-    alreadyCorrect: 0
-  };
-  const resolvePath = filePathResolver(store2);
-  for (const p of store2.findNodesByLabel("Problem")) {
-    try {
-      const anchors = store2.outEdges(p.id, ["ANCHORED_AT"]);
-      const legacy = anchors.filter((e) => e.attrs?.["anchorProvenance"] === "legacy");
-      if (legacy.length === 0) continue;
-      const better = anchors.filter((e) => {
-        const prov = e.attrs?.["anchorProvenance"];
-        return prov === "restated" || prov === "witnessed" || prov === "edited";
-      });
-      if (better.length > 0) {
-        const betterTargets = new Set(better.map((e) => e.to));
-        let retired = 0;
-        for (const e of legacy) {
-          if (!betterTargets.has(e.to)) {
-            store2.closeEdge(e.id, ts);
-            retired++;
-          }
-        }
-        report.retiredGuesses += retired;
-        continue;
-      }
-      const named = [...String(p.description ?? "").matchAll(STATEMENT_PATH_RE)].map((m) => m[0]);
-      if (named.length === 0) {
-        report.noPathNamed++;
-        continue;
-      }
-      const guessedPaths = legacy.map((e) => {
-        const f = store2.getNode(e.to);
-        return String(f?.attrs["relPath"] ?? f?.description ?? "");
-      });
-      if (named.some((x) => guessedPaths.some((g) => g.endsWith(x) || x.endsWith(g)))) {
-        report.alreadyCorrect++;
-        continue;
-      }
-      const target = named.map(resolvePath).find((f) => f !== null);
-      if (!target) {
-        report.pathUnknown++;
-        continue;
+function deriveContextFromAnchors(store2, problemId, ts, pkgIndex) {
+  const report = { languages: [], packages: [] };
+  const p = store2.getNode(problemId);
+  if (!p || p.label !== "Problem" && p.label !== "Vulnerability") return report;
+  const files = store2.outEdges(problemId, ["ANCHORED_AT"]).map((e) => store2.getNode(e.to)).filter((n) => !!n && n.label === "File");
+  if (files.length === 0) return report;
+  const idx = pkgIndex ?? buildPackageIndex(store2);
+  const haveLang = new Set(store2.outEdges(problemId, ["OCCURS_IN"]).map((e) => e.to));
+  const havePkg = new Set(store2.outEdges(problemId, ["DEPENDS_ON"]).map((e) => e.to));
+  for (const file2 of files) {
+    const lang = String(file2.attrs["language"] ?? "").trim();
+    if (lang) {
+      const langId = langNodeId(lang);
+      if (!store2.getNode(langId)) {
+        store2.mergeNode({
+          id: langId,
+          label: "Language",
+          description: lang,
+          extractionConfidence: 1,
+          extractionSource: "daemon-extracted",
+          embedding: [],
+          cumulativeSurprise: 0,
+          peakSurprise: 0,
+          cumulativeHits: 0,
+          lastUpdatedAt: ts,
+          createdAt: ts,
+          memoryTier: "short-term",
+          pageRank: 0,
+          isLandmark: false,
+          community: null,
+          stability: "stable",
+          attrs: { name: lang, workspaceId: file2.attrs["workspaceId"] }
+        });
       }
-      store2.mergeEdge(restatedAnchor(p.id, target.id, guessedPaths[0] ?? "", ts));
-      for (const e of legacy) {
-        if (e.to !== target.id) store2.closeEdge(e.id, ts);
+      if (!haveLang.has(langId)) {
+        mergeContextEdge(store2, problemId, langId, "OCCURS_IN", ts);
+        haveLang.add(langId);
+        report.languages.push(langId);
       }
-      report.retiredGuesses += legacy.filter((e) => e.to !== target.id).length;
-      report.repaired.push({
-        problemId: p.id,
-        problem: p.description,
-        guessed: guessedPaths[0] ?? "",
-        restated: target.path
-      });
-    } catch {
     }
-  }
-  return report;
-}
-function backfillLegacyAnchors(store2, ts) {
-  const report = {
-    demotedEdges: 0,
-    demotedProblems: 0,
-    restatedProblems: 0,
-    labeledEdges: 0,
-    suspects: []
-  };
-  let resolvePath;
-  for (const p of store2.findNodesByLabel("Problem")) {
-    const resolved = p.attrs["resolvedAt"] !== void 0;
-    const legacy = store2.outEdges(p.id, ["ANCHORED_AT"]).filter((e) => isLegacyAnchor(e.attrs) || !resolved && e.attrs?.["anchorProvenance"] === "legacy");
-    if (legacy.length === 0) continue;
-    try {
-      if (!resolved) {
-        resolvePath ??= filePathResolver(store2);
-        const target = statementTarget(String(p.description ?? ""), resolvePath);
-        if (target) {
-          const guessed = store2.getNode(legacy[0].to);
-          store2.mergeEdge(
-            restatedAnchor(p.id, target.id, String(guessed?.attrs["relPath"] ?? guessed?.description ?? ""), ts)
-          );
-          report.restatedProblems++;
-        }
-        const retired = legacy.filter((e) => !(target && e.to === target.id));
-        for (const e of retired) {
-          const file2 = store2.getNode(e.to);
-          const path = String(file2?.attrs["relPath"] ?? file2?.description ?? "");
-          if (path) recordAnchorHint(store2, p.id, path, "legacy", ts);
-          store2.closeEdge(e.id, ts);
-          report.demotedEdges++;
-        }
-        if (retired.length > 0) report.demotedProblems++;
-        continue;
-      }
-      for (const e of legacy) {
-        store2.mergeEdge({ ...e, attrs: { ...e.attrs, anchorProvenance: "legacy" }, lastSeenAt: ts });
-        report.labeledEdges++;
-      }
-      for (const se of store2.outEdges(p.id, ["SOLVED_BY"])) {
-        const sol = store2.getNode(se.to);
-        if (!sol || !sol.description.startsWith(AUTO_MINT_PREFIX)) continue;
-        const guessedAnchor = sol.description.slice(AUTO_MINT_PREFIX.length);
-        store2.updateNode(sol.id, {
-          attrs: { ...sol.attrs, provisional: true, resolutionSuspect: true },
-          lastUpdatedAt: ts
-        });
-        markRevisit(
-          store2,
-          sol,
-          `auto-closed off a pre-provenance anchor (guessed ${guessedAnchor}) \u2014 confirm the problem is really fixed, or reopen it`,
-          ts,
-          // "or reopen it" is half the ask, and the nightly reopen takes that
-          // branch — so record what would answer this, or the flag can never be
-          // lowered and the band fills with settled questions.
-          "parentProblemOpen"
-        );
-        store2.updateNode(p.id, {
-          attrs: { ...p.attrs, resolutionSuspect: true },
-          lastUpdatedAt: ts
-        });
-        report.suspects.push({
-          problemId: p.id,
-          problem: p.description,
-          solutionId: sol.id,
-          guessedAnchor
-        });
-      }
-    } catch {
+    for (const e of store2.outEdges(file2.id, ["IMPORTS"])) {
+      const mod = store2.getNode(e.to);
+      if (!mod) continue;
+      const name2 = specToPackageName(mod.description);
+      if (!name2) continue;
+      const pkg = idx.get(name2);
+      if (!pkg || havePkg.has(pkg.id)) continue;
+      addDependency(store2, {
+        fromId: problemId,
+        toId: pkg.id,
+        relation: "depends-on",
+        evidence: "imported by the anchored code",
+        ts,
+        extractionSource: "daemon-extracted"
+      });
+      havePkg.add(pkg.id);
+      report.packages.push(pkg.id);
+    }
+  }
+  return report;
+}
+function backfillProblemContext(store2, ts) {
+  const report = { problems: 0, edges: 0 };
+  const idx = buildPackageIndex(store2);
+  for (const p of store2.findNodesByLabel("Problem")) {
+    if (p.attrs["resolvedAs"] === "false_positive") continue;
+    const r = deriveContextFromAnchors(store2, p.id, ts, idx);
+    const n = r.languages.length + r.packages.length;
+    if (n > 0) {
+      report.problems++;
+      report.edges += n;
     }
   }
   return report;
 }
 
-// ../../packages/local-graph/src/percolate.ts
+// ../../packages/local-graph/src/design-problem.ts
 init_src2();
-init_src();
 
-// ../../packages/local-graph/src/abstraction.ts
+// ../../packages/local-graph/src/problem-dedup.ts
 init_src();
-init_src2();
-
-// ../../packages/math/src/pagerank.ts
-function pagerank(input) {
-  const damping = input.damping ?? 0.85;
-  const tol = input.tolerance ?? 1e-6;
-  const maxIter = input.maxIterations ?? 100;
-  const ids = input.nodeIds;
-  const n = ids.length;
-  if (n === 0) {
-    return { scores: /* @__PURE__ */ new Map(), iterations: 0, converged: true, danglingRank: 0 };
-  }
-  const index = /* @__PURE__ */ new Map();
-  for (let i2 = 0; i2 < n; i2++) index.set(ids[i2], i2);
-  const outSum = new Float64Array(n);
-  const dangling = new Uint8Array(n).fill(1);
-  const rowLen = new Int32Array(n);
-  let edgeCount = 0;
-  for (const [from, edges] of input.out) {
-    const fi = index.get(from);
-    if (fi === void 0) continue;
-    let sum = 0;
-    let inSet = 0;
-    for (const e of edges) {
-      sum += e.weight;
-      if (index.has(e.to)) inSet++;
-    }
-    if (sum > 0) {
-      outSum[fi] = sum;
-      dangling[fi] = 0;
+init_src();
+var REDIRECT_EDGES = [
+  "CAUSED_BY",
+  "SOLVED_BY",
+  "FIXED_BY",
+  "ANCHORED_AT",
+  "MANIFESTED_IN",
+  "EVIDENCED_BY"
+];
+function corroborations(n) {
+  return Number(n.attrs["corroborations"] ?? 0);
+}
+function overlap(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let inter = 0;
+  for (const x of a) if (b.has(x)) inter++;
+  return inter / Math.min(a.size, b.size);
+}
+function mergeDuplicateProblems(store2, opts) {
+  const minOverlap = opts.minOverlap ?? 0.85;
+  const minTokens = opts.minTokens ?? 4;
+  const report = { clusters: 0, merged: 0 };
+  const open = store2.findNodesByLabel("Problem").filter((p) => p.attrs["resolvedAt"] == null && p.attrs["mergedInto"] === void 0);
+  const tokens = /* @__PURE__ */ new Map();
+  for (const p of open) tokens.set(p.id, new Set(retrievalTokens(p.description)));
+  const consumed = /* @__PURE__ */ new Set();
+  store2.transaction(() => {
+    for (let i2 = 0; i2 < open.length; i2++) {
+      const a = open[i2];
+      if (consumed.has(a.id)) continue;
+      const cluster = [a];
+      const ta = tokens.get(a.id);
+      for (let j = i2 + 1; j < open.length; j++) {
+        const b = open[j];
+        if (consumed.has(b.id)) continue;
+        const tb = tokens.get(b.id);
+        if (Math.min(ta.size, tb.size) < minTokens) continue;
+        if (isConstraintProblem(a) !== isConstraintProblem(b)) continue;
+        if (overlap(ta, tb) >= minOverlap) {
+          cluster.push(b);
+          consumed.add(b.id);
+        }
+      }
+      if (cluster.length < 2) continue;
+      report.clusters++;
+      cluster.sort((x, y) => corroborations(y) - corroborations(x) || x.createdAt - y.createdAt);
+      const survivor = cluster[0];
+      for (const dup of cluster.slice(1)) {
+        foldDuplicateProblem(store2, dup, survivor, opts.ts);
+        report.merged++;
+      }
     }
-    rowLen[fi] = inSet;
-    edgeCount += inSet;
+  });
+  return report;
+}
+function foldDuplicateProblem(store2, dup, survivor, ts) {
+  const surv = store2.getNode(survivor.id);
+  if (!surv) return;
+  const sources = new Set(surv.attrs["sources"] ?? []);
+  for (const s of dup.attrs["sources"] ?? []) sources.add(s);
+  const dupSeq = dup.attrs["createdAtSeq"] ?? store2.currentIngestSeq();
+  const exposure = priorExposure(store2, survivor.id, dupSeq);
+  const expField = `reinforce${exposure[0].toUpperCase()}${exposure.slice(1)}Count`;
+  store2.updateNode(survivor.id, {
+    attrs: {
+      ...surv.attrs,
+      sources: [...sources],
+      corroborations: corroborations(surv) + corroborations(dup) + 1,
+      [expField]: (surv.attrs[expField] ?? 0) + 1,
+      lastReinforceExposure: exposure
+    },
+    cumulativeHits: (surv.cumulativeHits ?? 0) + (dup.cumulativeHits ?? 0),
+    lastUpdatedAt: ts
+  });
+  for (const e of store2.outEdges(dup.id, REDIRECT_EDGES)) {
+    if (e.to === survivor.id) continue;
+    const id = `edge_${digest({ from: survivor.id, type: e.type, to: e.to })}`.slice(0, 24);
+    if (store2.getEdge(id)) continue;
+    const redirected = {
+      ...e,
+      id,
+      from: survivor.id,
+      createdAt: ts,
+      lastSeenAt: ts
+    };
+    store2.mergeEdge(redirected);
   }
-  const rowStart = new Int32Array(n + 1);
-  for (let i2 = 0; i2 < n; i2++) rowStart[i2 + 1] = rowStart[i2] + rowLen[i2];
-  const colIdx = new Int32Array(edgeCount);
-  const colW = new Float64Array(edgeCount);
-  const cursor = rowStart.slice(0, n);
-  for (const [from, edges] of input.out) {
-    const fi = index.get(from);
-    if (fi === void 0) continue;
-    for (const e of edges) {
-      const ti = index.get(e.to);
-      if (ti === void 0) continue;
-      const c = cursor[fi];
-      cursor[fi] = c + 1;
-      colIdx[c] = ti;
-      colW[c] = e.weight;
-    }
+  store2.updateNode(dup.id, {
+    attrs: { ...dup.attrs, mergedInto: survivor.id, resolvedAs: "duplicate", resolvedAt: ts },
+    lastUpdatedAt: ts
+  });
+  store2.closeNode(dup.id, ts);
+}
+
+// ../../packages/local-graph/src/design-problem.ts
+init_src();
+function isConstraintProblem(node) {
+  return node.attrs["kind"] === "constraint";
+}
+var RECURRENCE_DEBOUNCE_MS = 60 * 60 * 1e3;
+function resolveFileNode(store2, path, workspaceId) {
+  const want = path.trim().replace(/^\.?\//, "");
+  for (const n of store2.findNodesByLabel("File")) {
+    if (n.attrs["workspaceId"] && n.attrs["workspaceId"] !== workspaceId) continue;
+    if (n.attrs["relPath"] === want || n.description === want) return n;
   }
-  let score2 = new Float64Array(n).fill(1 / n);
-  let next = new Float64Array(n);
-  const base = (1 - damping) / n;
-  let iter = 0;
-  let converged = false;
-  for (; iter < maxIter; iter++) {
-    next.fill(base);
-    let danglingMass = 0;
-    for (let i2 = 0; i2 < n; i2++) if (dangling[i2]) danglingMass += score2[i2];
-    for (let i2 = 0; i2 < n; i2++) {
-      if (dangling[i2]) continue;
-      const f = damping * score2[i2] / outSum[i2];
-      const end = rowStart[i2 + 1];
-      for (let c = rowStart[i2]; c < end; c++) next[colIdx[c]] += f * colW[c];
-    }
-    if (danglingMass > 0) {
-      const share = damping * danglingMass / n;
-      for (let i2 = 0; i2 < n; i2++) next[i2] += share;
-    }
-    let diff = 0;
-    for (let i2 = 0; i2 < n; i2++) diff += Math.abs(next[i2] - score2[i2]);
-    const tmp = score2;
-    score2 = next;
-    next = tmp;
-    if (diff < tol) {
-      iter++;
-      converged = true;
+  return null;
+}
+var CITABLE_PRIOR_LABELS = /* @__PURE__ */ new Set([
+  "Solution",
+  "RootCause",
+  "Pattern",
+  "Technique",
+  "AntiPattern"
+]);
+function isAutoMinted(n) {
+  return isEditPlaceholderSolution(n);
+}
+function priorsForFile(store2, relPath) {
+  const want = relPath.trim().replace(/^\.?\//, "");
+  let file2 = null;
+  for (const n of store2.findNodesByLabel("File")) {
+    if (n.description === want || n.attrs["relPath"] === want) {
+      file2 = n;
       break;
     }
   }
-  const scores = /* @__PURE__ */ new Map();
-  let danglingRank = 0;
-  for (let i2 = 0; i2 < n; i2++) {
-    scores.set(ids[i2], score2[i2]);
-    if (dangling[i2]) danglingRank += score2[i2];
-  }
-  return { scores, iterations: iter, converged, danglingRank };
-}
-function markLandmarks(scores, percentile = 0.1, filter) {
-  const entries = [...scores.entries()];
-  if (filter) {
-    for (let i2 = entries.length - 1; i2 >= 0; i2--) {
-      if (!filter(entries[i2][0])) entries.splice(i2, 1);
+  if (!file2) return null;
+  const openProblems = [];
+  const constraints = [];
+  const resolvedProblems = [];
+  const seenProblem = /* @__PURE__ */ new Set();
+  const related = /* @__PURE__ */ new Map();
+  const anchorEdges = [
+    ...store2.inEdges(file2.id, ["ANCHORED_AT"]),
+    ...store2.outEdges(file2.id, ["DEFINES"]).flatMap((d) => store2.inEdges(d.to, ["ANCHORED_AT"]))
+  ];
+  for (const e of anchorEdges) {
+    const n = store2.getNode(e.from);
+    if (!n) continue;
+    if (n.label === "Problem" || n.label === "Vulnerability") {
+      if (seenProblem.has(n.id)) continue;
+      seenProblem.add(n.id);
+      if (!n.attrs["resolvedAt"]) {
+        (isConstraintProblem(n) ? constraints : openProblems).push(n);
+      } else if (n.attrs["resolvedAs"] == null && n.attrs["mergedInto"] === void 0 && e.attrs?.["anchorProvenance"] !== "legacy") {
+        resolvedProblems.push(n);
+      }
+    } else if (CITABLE_PRIOR_LABELS.has(n.label) && !isAutoMinted(n)) {
+      related.set(n.id, n);
     }
   }
-  if (entries.length === 0) return /* @__PURE__ */ new Set();
-  entries.sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
-  const cutoff = Math.max(1, Math.floor(entries.length * percentile));
-  const out2 = /* @__PURE__ */ new Set();
-  for (let i2 = 0; i2 < cutoff; i2++) {
-    out2.add(entries[i2][0]);
+  const solutionsByProblem = /* @__PURE__ */ new Map();
+  for (const p of [...openProblems, ...constraints, ...resolvedProblems]) {
+    for (const e of store2.outEdges(p.id, ["SOLVED_BY", "CAUSED_BY", "INSTANCE_OF"])) {
+      const n = store2.getNode(e.to);
+      if (n && CITABLE_PRIOR_LABELS.has(n.label) && !isAutoMinted(n)) related.set(n.id, n);
+      if (n && n.label === "Solution" && e.type === "SOLVED_BY" && !isAutoMinted(n)) {
+        const list = solutionsByProblem.get(p.id) ?? [];
+        if (!list.some((s) => s.id === n.id)) list.push(n);
+        solutionsByProblem.set(p.id, list);
+      }
+    }
   }
-  return out2;
+  if (openProblems.length === 0 && constraints.length === 0 && resolvedProblems.length === 0 && related.size === 0)
+    return null;
+  const recentFirst = (a, b) => (b.lastUpdatedAt ?? 0) - (a.lastUpdatedAt ?? 0);
+  openProblems.sort(recentFirst);
+  constraints.sort(recentFirst);
+  resolvedProblems.sort(
+    (a, b) => Number(b.attrs["resolvedAt"] ?? 0) - Number(a.attrs["resolvedAt"] ?? 0)
+  );
+  return {
+    file: file2,
+    openProblems,
+    constraints,
+    resolvedProblems,
+    related: [...related.values()],
+    solutionsByProblem
+  };
 }
-
-// ../../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);
+function anchorProblemToWorkingFile(store2, problemId, relPath, workspaceId, ts, provenance = "edited", opts = {}) {
+  const p = store2.getNode(problemId);
+  if (!p || p.label !== "Problem" && p.label !== "Vulnerability") return false;
+  if (p.label === "Vulnerability" && provenance !== "witnessed") return false;
+  if (!isAnchorableCodePath(relPath)) return false;
+  const file2 = resolveFileNode(store2, relPath, workspaceId);
+  if (!file2) return false;
+  const already = new Set(store2.outEdges(problemId, ["ANCHORED_AT"]).map((e) => e.to));
+  const confidence = provenance === "witnessed" ? 0.4 : 0.3;
+  if (!already.has(file2.id)) {
+    store2.mergeEdge({
+      id: `edge_${digest({ from: problemId, type: "ANCHORED_AT", to: file2.id })}`.slice(0, 24),
+      from: problemId,
+      to: file2.id,
+      type: "ANCHORED_AT",
+      confidence,
+      extractionSource: "agent-observed",
+      createdAt: ts,
+      lastSeenAt: ts,
+      navSuccesses: 0,
+      navFailures: 0,
+      attrs: { provisional: true, captureTime: true, anchorProvenance: provenance }
+    });
   }
-  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;
+  if (opts.line !== void 0 && opts.fileText !== void 0) {
+    const sym = resolveEnclosingSymbol(store2, file2.id, opts.line, opts.fileText);
+    if (sym && !already.has(sym.id)) {
+      store2.mergeEdge({
+        id: `edge_${digest({ from: problemId, type: "ANCHORED_AT", to: sym.id })}`.slice(0, 24),
+        from: problemId,
+        to: sym.id,
+        type: "ANCHORED_AT",
+        confidence,
+        extractionSource: "agent-observed",
+        createdAt: ts,
+        lastSeenAt: ts,
+        navSuccesses: 0,
+        navFailures: 0,
+        attrs: {
+          provisional: true,
+          captureTime: true,
+          anchorProvenance: provenance,
+          anchorLine: opts.line,
+          enclosingSymbol: true,
+          // PJ-anchor-version: WHICH version of the symbol this was witnessed
+          // against. `bodyHash` is the indexer's 16-hex sha256 of the body;
+          // `headSha` is the checkout's HEAD at capture. Both opaque, both
+          // cross the membrane on the anchor edge, and a teammate's reanchor
+          // compares the hash with their own symbol to tell "current" from
+          // "pre-change" — the branch hazard where a fix witnessed on feat/x
+          // would otherwise read as a fact about the unchanged symbol on dev.
+          ...typeof sym.attrs["bodyHash"] === "string" ? { symbolContentHash: sym.attrs["bodyHash"] } : {},
+          ...opts.headSha ? { observedAtCommit: opts.headSha } : {}
+        }
+      });
     }
   }
-  return { nbr, deg, m2 };
+  return true;
 }
-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;
+var ENCLOSING_SYMBOL_KINDS = /* @__PURE__ */ new Set([
+  "Function",
+  "Class",
+  "Method",
+  "Module",
+  "Interface",
+  "Const",
+  "Enum",
+  "TypeAlias",
+  "Namespace",
+  "Property"
+]);
+var ENCLOSING_WALK_DEPTH = 8;
+function resolveEnclosingSymbol(store2, fileId, line, fileText) {
+  if (!Number.isFinite(line) || line < 1) return null;
+  const row = Math.floor(line) - 1;
+  const lineStarts = [0];
+  for (let i2 = 0; i2 < fileText.length; i2++) if (fileText.charCodeAt(i2) === 10) lineStarts.push(i2 + 1);
+  const rowOf = (index) => {
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (lineStarts[mid] <= index) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo;
+  };
+  let best = null;
+  let bestStart = -1;
+  let bestSpan = Number.POSITIVE_INFINITY;
+  const seen = /* @__PURE__ */ new Set([fileId]);
+  let frontier = [fileId];
+  for (let depth = 0; depth < ENCLOSING_WALK_DEPTH && frontier.length > 0; depth++) {
+    const next = [];
+    for (const id of frontier) {
+      for (const e of store2.outEdges(id, ["DEFINES"])) {
+        if (seen.has(e.to)) continue;
+        seen.add(e.to);
+        const n = store2.getNode(e.to);
+        if (!n) continue;
+        next.push(n.id);
+        if (!ENCLOSING_SYMBOL_KINDS.has(n.label)) continue;
+        const startRow = n.attrs["startRow"];
+        const startByte = n.attrs["startByte"];
+        const endByte = n.attrs["endByte"];
+        if (typeof startRow !== "number" || typeof startByte !== "number" || typeof endByte !== "number") continue;
+        if (startRow < 0 || endByte < startByte) continue;
+        const endRow = rowOf(Math.max(startByte, Math.min(endByte, fileText.length) - 1));
+        if (row < startRow || row > endRow) continue;
+        const span = endByte - startByte;
+        if (startRow > bestStart || startRow === bestStart && span < bestSpan) {
+          best = n;
+          bestStart = startRow;
+          bestSpan = span;
         }
       }
-      community.set(node, bestC);
-      comTot.set(bestC, (comTot.get(bestC) ?? 0) + ki);
-      if (bestC !== ci) improved = true;
     }
+    frontier = next;
   }
-  return community;
+  return best;
 }
-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);
+function recordAnchorHint(store2, problemId, relPath, provenance, ts) {
+  const p = store2.getNode(problemId);
+  if (!p || p.label !== "Problem") return false;
+  if (p.attrs["anchorHint"]) return false;
+  store2.updateNode(problemId, {
+    attrs: { ...p.attrs, anchorHint: { path: relPath, provenance, ts } }
+  });
+  return true;
+}
+function openAnchorHint(p) {
+  const h = p.attrs["anchorHint"];
+  if (!h || typeof h.path !== "string" || h.upgradedAt) return null;
+  return { path: h.path, ts: typeof h.ts === "number" ? h.ts : 0 };
+}
+function consumeAnchorHint(store2, p, ts) {
+  const hint = p.attrs["anchorHint"];
+  store2.updateNode(p.id, { attrs: { ...p.attrs, anchorHint: { ...hint, upgradedAt: ts } } });
+  deriveContextFromAnchors(store2, p.id, ts);
+}
+function upgradeAnchorHints(store2, workspaceId, ts) {
+  let upgraded = 0;
+  let standing = 0;
+  let unresolvable = 0;
+  let blocked = 0;
+  const filesByPath = /* @__PURE__ */ new Map();
+  for (const f of store2.findNodesByLabel("File")) {
+    if (f.attrs["workspaceId"] && f.attrs["workspaceId"] !== workspaceId) continue;
+    const rel = typeof f.attrs["relPath"] === "string" ? f.attrs["relPath"] : f.description;
+    if (rel && !filesByPath.has(rel)) filesByPath.set(rel, f);
   }
-  const refined = /* @__PURE__ */ new Map();
-  for (const [, group] of members) {
-    const inGroup = new Set(group);
-    const seen = /* @__PURE__ */ new Set();
-    for (const start2 of [...group].sort()) {
-      if (seen.has(start2)) continue;
-      const comp = [];
-      const stack = [start2];
-      seen.add(start2);
-      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);
+  for (const p of store2.findNodesByLabel("Problem")) {
+    if (p.validTo != null || p.attrs["resolvedAt"]) continue;
+    const hint = openAnchorHint(p);
+    if (!hint) continue;
+    const file2 = filesByPath.get(hint.path.trim().replace(/^\.?\//, ""));
+    if (!file2 || !isAnchorableCodePath(hint.path)) {
+      unresolvable++;
+      continue;
+    }
+    standing++;
+    const changedAt = Number(file2.attrs["contentChangedAt"] ?? 0);
+    if (changedAt <= hint.ts) continue;
+    if (anchorProblemToWorkingFile(store2, p.id, hint.path, workspaceId, ts, "hint-confirmed")) {
+      consumeAnchorHint(store2, p, ts);
+      upgraded++;
+      standing--;
+    } else {
+      blocked++;
     }
   }
-  return refined;
+  return { upgraded, standing, unresolvable, blocked };
 }
-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);
+function reopenAutoClosedProblems(store2, t) {
+  const report = { reopened: 0, alreadySuspect: 0, agentDescribed: 0 };
+  for (const p of store2.findNodesByLabel("Problem")) {
+    if (p.attrs["resolvedAt"] == null) continue;
+    if (p.attrs["resolvedAs"] != null) continue;
+    if (p.attrs["mergedInto"] !== void 0) continue;
+    if (p.attrs["resolutionWitnessed"] === true) {
+      report.agentDescribed++;
+      continue;
+    }
+    const sols = store2.outEdges(p.id, ["SOLVED_BY"]).map((e) => store2.getNode(e.to)).filter((n) => n !== null);
+    if (sols.length === 0 && p.attrs["retiredEditPlaceholder"] !== true) continue;
+    if (!sols.every((s) => String(s.description ?? "").startsWith(AUTO_MINT_PREFIX))) {
+      report.agentDescribed++;
+      continue;
+    }
+    if (p.attrs["resolutionSuspect"] === true) report.alreadySuspect++;
+    const attrs = { ...p.attrs };
+    delete attrs["resolvedAt"];
+    attrs["reopenedFrom"] = "auto-close";
+    attrs["reopenedAt"] = t;
+    store2.updateNode(p.id, { attrs, lastUpdatedAt: t });
+    report.reopened++;
   }
-  return { community, count: groups.size, iterations: 1 };
+  return report;
 }
-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;
+function markFixCandidates(store2, t) {
+  let resolved = 0;
+  for (const p of store2.findNodesByLabel("Problem")) {
+    if (!p.id.startsWith("dprob_")) continue;
+    if (p.attrs["resolvedAt"]) continue;
+    if (isConstraintProblem(p)) continue;
+    let symName = "";
+    let symRelPath;
+    let edited = false;
+    const since = Math.max(p.createdAt, Number(p.attrs["fixCandidateClearedAt"] ?? 0));
+    for (const e of store2.outEdges(p.id, ["ANCHORED_AT"])) {
+      if (e.attrs?.["mention"] === true) continue;
+      if (e.attrs?.["anchorProvenance"] === "legacy") continue;
+      const sym = store2.getNode(e.to);
+      const changedAt = sym?.label === "File" ? Number(sym.attrs["contentChangedAt"] ?? 0) : sym?.lastUpdatedAt ?? 0;
+      if (sym && changedAt > since) {
+        edited = true;
+        symName = sym.description;
+        symRelPath = sym.attrs["relPath"] ?? void 0;
+        break;
+      }
     }
-    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);
+    if (!edited) continue;
+    if (p.attrs["fixCandidateAt"] !== void 0) continue;
+    if (store2.outEdges(p.id, ["SOLVED_BY"]).some((e) => {
+      const s = store2.getNode(e.to);
+      return s !== null && !String(s.description ?? "").startsWith(AUTO_MINT_PREFIX);
+    }))
+      continue;
+    store2.updateNode(p.id, {
+      attrs: {
+        ...p.attrs,
+        // The cue, kept as structured data so the render can name the file it is
+        // asking about. Deliberately NOT `resolvedAt` — this is a question.
+        fixCandidateAt: t,
+        fixCandidateSymbol: symName,
+        ...symRelPath ? { fixCandidateFile: symRelPath } : {},
+        // Snapshot the render-ledger counter so "shown since THIS ask" is
+        // measurable. `shownCount` is the node's LIFETIME count across every
+        // band, so comparing it raw would retire a fresh ask on a
+        // frequently-surfaced problem before anyone had seen the question once.
+        fixCandidateShownBase: Number(p.attrs["shownCount"] ?? 0)
+      }
+      // No `lastUpdatedAt`: raising a question is bookkeeping, not a new
+      // observation of the problem, and the passive block's recent-problems band
+      // sorts on that field (see clearSettledFixCandidates).
+    });
+    resolved++;
   }
-  return find;
+  return resolved;
 }
-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);
+var FIX_CANDIDATE_ASK_LIMIT = 5;
+function clearSettledFixCandidates(store2, t) {
+  const report = { answered: 0, ignored: 0, unsubstantiated: 0, standing: 0 };
+  for (const p of store2.findNodesByLabel("Problem")) {
+    if (p.attrs["fixCandidateAt"] === void 0) continue;
+    const fileAnchors = store2.outEdges(p.id, ["ANCHORED_AT"]).filter((e) => e.attrs?.["mention"] !== true && e.attrs?.["anchorProvenance"] !== "legacy").map((e) => store2.getNode(e.to)).filter((n) => n !== null && n.label === "File");
+    const unsubstantiated = fileAnchors.length > 0 && fileAnchors.every((f) => f.attrs["contentChangedAt"] === void 0);
+    const answered = p.attrs["resolvedAt"] != null || store2.outEdges(p.id, ["SOLVED_BY"]).some((e) => {
+      const s = store2.getNode(e.to);
+      return s !== null && !String(s.description ?? "").startsWith(AUTO_MINT_PREFIX);
+    });
+    const base = Number(
+      p.attrs["fixCandidateShownBase"] ?? p.attrs["shownCount"] ?? 0
+    );
+    const shownSinceAsk = Number(p.attrs["shownCount"] ?? 0) - base;
+    const ignored = shownSinceAsk >= FIX_CANDIDATE_ASK_LIMIT;
+    if (!answered && !ignored && !unsubstantiated) {
+      report.standing++;
+      continue;
     }
+    const attrs = { ...p.attrs };
+    delete attrs["fixCandidateAt"];
+    delete attrs["fixCandidateSymbol"];
+    delete attrs["fixCandidateFile"];
+    attrs["fixCandidateClearedAt"] = t;
+    store2.updateNode(p.id, { attrs });
+    if (answered) report.answered++;
+    else if (ignored) report.ignored++;
+    else report.unsubstantiated++;
   }
-  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);
+  return report;
 }
-
-// ../../packages/math/src/bko/a1-stable-motif.ts
-var MIN_INSTANCES = 5;
-var MIN_SURVIVED_RUNS = 2;
-function a1StableMotif(input) {
-  if (input.instanceCount >= MIN_INSTANCES && input.survivedRuns >= MIN_SURVIVED_RUNS) {
-    return {
-      shouldMarkStable: true,
-      confidence: Math.min(1, input.instanceCount / 20),
-      rule: "A1"
-    };
-  }
-  return { shouldMarkStable: false, confidence: 0, rule: "A1" };
+function priorExposure(store2, nodeId, atSeq) {
+  const n = store2.getNode(nodeId);
+  if (!n || !n.attrs) return "unshown";
+  const shownSeq = n.attrs["lastShownAtSeq"];
+  if (shownSeq !== void 0 && shownSeq <= atSeq) return "shown";
+  const evictedSeq = n.attrs["lastEvictedAtSeq"];
+  if (evictedSeq !== void 0 && evictedSeq <= atSeq) return "evicted";
+  if ((n.attrs["evictedCount"] ?? 0) > 0) return "evicted";
+  return "unshown";
 }
 
-// ../../packages/math/src/bko/a2-motif-quality.ts
-var MIN_INSTANCES2 = 3;
-var MIN_QUALITY = 0.65;
-var MAX_FAILURE_RATE = 0.15;
-var QUALITY_BOOST = 1.2;
-function a2MotifQuality(input) {
-  if (input.instances.length === 0) {
-    return {
-      qualityScore: 0,
-      qualityFailureRate: 0,
-      qualified: false,
-      qualityBoost: 1,
-      rule: "A2"
-    };
-  }
-  const mean = input.instances.reduce((s, i2) => s + i2.confidence, 0) / input.instances.length;
-  const failures = input.instances.filter((i2) => i2.failed).length;
-  const failureRate = failures / input.instances.length;
-  const qualified = input.instances.length >= MIN_INSTANCES2 && mean >= MIN_QUALITY && failureRate <= MAX_FAILURE_RATE;
-  return {
-    qualityScore: mean,
-    qualityFailureRate: failureRate,
-    qualified,
-    qualityBoost: qualified ? QUALITY_BOOST : 1,
-    rule: "A2"
-  };
-}
+// ../../packages/local-graph/src/intent.ts
+init_src();
 
-// ../../packages/math/src/motif-gate.ts
-var MOTIF_MIN_MEMBERS = 5;
-var MOTIF_MIN_SURVIVED = 2;
-function motifDecision(input) {
-  if (input.memberCount < MOTIF_MIN_MEMBERS) {
-    return {
-      isCandidate: false,
-      survivedRuns: input.priorSurvivedRuns,
-      stable: false,
-      qualified: false,
-      promoted: false,
-      motifConfidence: 0
-    };
+// ../../packages/local-graph/src/anchor-backfill.ts
+init_src();
+init_src2();
+function isLegacyAnchor(attrs) {
+  return attrs?.["captureTime"] === true && attrs["anchorProvenance"] === void 0;
+}
+var STATEMENT_PATH_RE = new RegExp(
+  String.raw`(?:[\w.+-]+\/)+[\w.+-]+\.(?:${anchorableExtensionAlternation()})`,
+  "g"
+);
+function filePathResolver(store2) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const f of store2.findNodesByLabel("File")) {
+    const path = String(f.attrs["relPath"] ?? f.description ?? "");
+    if (path) byPath.set(path, { id: f.id, path });
+  }
+  return (named) => {
+    const exact = byPath.get(named);
+    if (exact) return exact;
+    const hits = [...byPath.values()].filter(
+      (f) => f.path.endsWith(`/${named}`) || named.endsWith(`/${f.path}`)
+    );
+    return hits.length === 1 ? hits[0] : null;
+  };
+}
+function statementTarget(statement, resolvePath) {
+  for (const m of statement.matchAll(STATEMENT_PATH_RE)) {
+    const f = resolvePath(m[0]);
+    if (f) return f;
   }
-  const survivedRuns = input.priorSurvivedRuns + 1;
-  const a2 = a2MotifQuality({ instances: input.instances });
-  const a1 = a1StableMotif({ instanceCount: input.instanceCount, survivedRuns });
-  const stable = a1.shouldMarkStable;
-  const promoted = survivedRuns >= MOTIF_MIN_SURVIVED && stable && a2.qualified;
+  return null;
+}
+function restatedAnchor(problemId, fileId, restatedFrom, ts) {
   return {
-    isCandidate: true,
-    survivedRuns,
-    stable,
-    qualified: a2.qualified,
-    promoted,
-    motifConfidence: Math.round(a2.qualityScore * 100) / 100
+    id: `edge_${digest({ from: problemId, type: "ANCHORED_AT", to: fileId })}`.slice(0, 24),
+    from: problemId,
+    to: fileId,
+    type: "ANCHORED_AT",
+    // Same confidence a capture-time anchor enters at: the source is the
+    // agent's own statement either way, only the moment of reading differs.
+    confidence: 0.4,
+    extractionSource: "agent-observed",
+    createdAt: ts,
+    lastSeenAt: ts,
+    navSuccesses: 0,
+    navFailures: 0,
+    attrs: { anchorProvenance: "restated", restatedFrom, restatedAt: ts }
   };
 }
-
-// ../../packages/math/src/pagerank-local.ts
-function pagerankLocal(input) {
-  const damping = input.damping ?? 0.85;
-  const tol = input.tolerance ?? 1e-6;
-  const maxIter = input.maxIterations ?? 100;
-  const ids = input.regionIds;
-  const n = ids.length;
-  if (n === 0 || input.globalN === 0) {
-    return { scores: /* @__PURE__ */ new Map(), iterations: 0, converged: true };
-  }
-  const index = /* @__PURE__ */ new Map();
-  for (let i2 = 0; i2 < n; i2++) index.set(ids[i2], i2);
-  const base = (1 - damping) / input.globalN;
-  const outSum = new Float64Array(n);
-  const inflow = new Float64Array(n);
-  let score2 = new Float64Array(n);
-  for (let i2 = 0; i2 < n; i2++) {
-    const id = ids[i2];
-    outSum[i2] = input.outSum.get(id) ?? 0;
-    inflow[i2] = input.boundaryInflow.get(id) ?? 0;
-    score2[i2] = input.rank0.get(id) ?? base;
-  }
-  const rowLen = new Int32Array(n);
-  let edgeCount = 0;
-  for (const [from, edges] of input.out) {
-    const fi = index.get(from);
-    if (fi === void 0) continue;
-    let inSet = 0;
-    for (const e of edges) if (index.has(e.to)) inSet++;
-    rowLen[fi] = inSet;
-    edgeCount += inSet;
-  }
-  const rowStart = new Int32Array(n + 1);
-  for (let i2 = 0; i2 < n; i2++) rowStart[i2 + 1] = rowStart[i2] + rowLen[i2];
-  const colIdx = new Int32Array(edgeCount);
-  const colW = new Float64Array(edgeCount);
-  const cursor = rowStart.slice(0, n);
-  for (const [from, edges] of input.out) {
-    const fi = index.get(from);
-    if (fi === void 0) continue;
-    for (const e of edges) {
-      const ti = index.get(e.to);
-      if (ti === void 0) continue;
-      const c = cursor[fi];
-      cursor[fi] = c + 1;
-      colIdx[c] = ti;
-      colW[c] = e.weight;
+function repairLegacyAnchorsFromStatement(store2, ts) {
+  const report = {
+    repaired: [],
+    retiredGuesses: 0,
+    noPathNamed: 0,
+    pathUnknown: 0,
+    alreadyCorrect: 0
+  };
+  const resolvePath = filePathResolver(store2);
+  for (const p of store2.findNodesByLabel("Problem")) {
+    try {
+      const anchors = store2.outEdges(p.id, ["ANCHORED_AT"]);
+      const legacy = anchors.filter((e) => e.attrs?.["anchorProvenance"] === "legacy");
+      if (legacy.length === 0) continue;
+      const better = anchors.filter((e) => {
+        const prov = e.attrs?.["anchorProvenance"];
+        return prov === "restated" || prov === "witnessed" || prov === "edited";
+      });
+      if (better.length > 0) {
+        const betterTargets = new Set(better.map((e) => e.to));
+        let retired = 0;
+        for (const e of legacy) {
+          if (!betterTargets.has(e.to)) {
+            store2.closeEdge(e.id, ts);
+            retired++;
+          }
+        }
+        report.retiredGuesses += retired;
+        continue;
+      }
+      const named = [...String(p.description ?? "").matchAll(STATEMENT_PATH_RE)].map((m) => m[0]);
+      if (named.length === 0) {
+        report.noPathNamed++;
+        continue;
+      }
+      const guessedPaths = legacy.map((e) => {
+        const f = store2.getNode(e.to);
+        return String(f?.attrs["relPath"] ?? f?.description ?? "");
+      });
+      if (named.some((x) => guessedPaths.some((g) => g.endsWith(x) || x.endsWith(g)))) {
+        report.alreadyCorrect++;
+        continue;
+      }
+      const target = named.map(resolvePath).find((f) => f !== null);
+      if (!target) {
+        report.pathUnknown++;
+        continue;
+      }
+      store2.mergeEdge(restatedAnchor(p.id, target.id, guessedPaths[0] ?? "", ts));
+      for (const e of legacy) {
+        if (e.to !== target.id) store2.closeEdge(e.id, ts);
+      }
+      report.retiredGuesses += legacy.filter((e) => e.to !== target.id).length;
+      report.repaired.push({
+        problemId: p.id,
+        problem: p.description,
+        guessed: guessedPaths[0] ?? "",
+        restated: target.path
+      });
+    } catch {
     }
   }
-  const externalDangling = input.externalDanglingRank ?? 0;
-  let next = new Float64Array(n);
-  let iter = 0;
-  let converged = false;
-  for (; iter < maxIter; iter++) {
-    let internalDangling = 0;
-    for (let i2 = 0; i2 < n; i2++) if (outSum[i2] <= 0) internalDangling += score2[i2];
-    const danglingShare = damping * (internalDangling + externalDangling) / input.globalN;
-    for (let i2 = 0; i2 < n; i2++) next[i2] = base + danglingShare + damping * inflow[i2];
-    for (let i2 = 0; i2 < n; i2++) {
-      const os2 = outSum[i2];
-      if (os2 <= 0) continue;
-      const f = damping * score2[i2] / os2;
-      const end = rowStart[i2 + 1];
-      for (let c = rowStart[i2]; c < end; c++) next[colIdx[c]] += f * colW[c];
-    }
-    let diff = 0;
-    for (let i2 = 0; i2 < n; i2++) diff += Math.abs(next[i2] - score2[i2]);
-    const tmp = score2;
-    score2 = next;
-    next = tmp;
-    if (diff < tol) {
-      iter++;
-      converged = true;
-      break;
+  return report;
+}
+function backfillLegacyAnchors(store2, ts) {
+  const report = {
+    demotedEdges: 0,
+    demotedProblems: 0,
+    restatedProblems: 0,
+    labeledEdges: 0,
+    suspects: []
+  };
+  let resolvePath;
+  for (const p of store2.findNodesByLabel("Problem")) {
+    const resolved = p.attrs["resolvedAt"] !== void 0;
+    const legacy = store2.outEdges(p.id, ["ANCHORED_AT"]).filter((e) => isLegacyAnchor(e.attrs) || !resolved && e.attrs?.["anchorProvenance"] === "legacy");
+    if (legacy.length === 0) continue;
+    try {
+      if (!resolved) {
+        resolvePath ??= filePathResolver(store2);
+        const target = statementTarget(String(p.description ?? ""), resolvePath);
+        if (target) {
+          const guessed = store2.getNode(legacy[0].to);
+          store2.mergeEdge(
+            restatedAnchor(p.id, target.id, String(guessed?.attrs["relPath"] ?? guessed?.description ?? ""), ts)
+          );
+          report.restatedProblems++;
+        }
+        const retired = legacy.filter((e) => !(target && e.to === target.id));
+        for (const e of retired) {
+          const file2 = store2.getNode(e.to);
+          const path = String(file2?.attrs["relPath"] ?? file2?.description ?? "");
+          if (path) recordAnchorHint(store2, p.id, path, "legacy", ts);
+          store2.closeEdge(e.id, ts);
+          report.demotedEdges++;
+        }
+        if (retired.length > 0) report.demotedProblems++;
+        continue;
+      }
+      for (const e of legacy) {
+        store2.mergeEdge({ ...e, attrs: { ...e.attrs, anchorProvenance: "legacy" }, lastSeenAt: ts });
+        report.labeledEdges++;
+      }
+      for (const se of store2.outEdges(p.id, ["SOLVED_BY"])) {
+        const sol = store2.getNode(se.to);
+        if (!sol || !sol.description.startsWith(AUTO_MINT_PREFIX)) continue;
+        const guessedAnchor = sol.description.slice(AUTO_MINT_PREFIX.length);
+        store2.updateNode(sol.id, {
+          attrs: { ...sol.attrs, provisional: true, resolutionSuspect: true },
+          lastUpdatedAt: ts
+        });
+        markRevisit(
+          store2,
+          sol,
+          `auto-closed off a pre-provenance anchor (guessed ${guessedAnchor}) \u2014 confirm the problem is really fixed, or reopen it`,
+          ts,
+          // "or reopen it" is half the ask, and the nightly reopen takes that
+          // branch — so record what would answer this, or the flag can never be
+          // lowered and the band fills with settled questions.
+          "parentProblemOpen"
+        );
+        store2.updateNode(p.id, {
+          attrs: { ...p.attrs, resolutionSuspect: true },
+          lastUpdatedAt: ts
+        });
+        report.suspects.push({
+          problemId: p.id,
+          problem: p.description,
+          solutionId: sol.id,
+          guessedAnchor
+        });
+      }
+    } catch {
     }
   }
-  const scores = /* @__PURE__ */ new Map();
-  for (let i2 = 0; i2 < n; i2++) scores.set(ids[i2], score2[i2]);
-  return { scores, iterations: iter, converged };
+  return report;
 }
 
+// ../../packages/local-graph/src/percolate.ts
+init_src2();
+init_src();
+
+// ../../packages/local-graph/src/abstraction.ts
+init_src();
+init_src2();
+
 // ../../packages/local-graph/src/triage.ts
 init_src();
 init_src();
@@ -28813,6 +28907,7 @@ function tryIncrementalRescore(store2, lastRescoreAt, started) {
       store2.setPageRank(id, score2);
       pageRankWritten++;
     }
+    if (pageRankWritten > 0) store2.refreshPageRankScale?.();
   });
   const sweep = store2.landmarkSweepRows();
   const candidates = /* @__PURE__ */ new Map();
@@ -28883,6 +28978,7 @@ function runFullRescore(store2) {
       store2.setPageRank(id, score2);
       pageRankWritten++;
     }
+    store2.refreshPageRankScale?.();
   });
   const landmarkCandidates = /* @__PURE__ */ new Map();
   for (const [id, score2] of result.scores) {