@inerrata-corporation/errata 2.0.2-dev.133 → 2.0.2-dev.1411

package/pass-worker.mjs

@@ -212,7 +212,7 @@ var init_castalia = __esm({
     DECOMPOSITION_EDGES = ["SPLIT_INTO"];
     TRANSFER_EDGES = ["MAY_RESOLVE"];
     SOLUTION_STRUCTURE_EDGES = ["BUILDS_ON", "SUPERSEDES", "ALTERNATIVE_TO"];
-    SUSPICION_EDGES = ["SUSPECTED_LINK"];
+    SUSPICION_EDGES = ["SUSPECTED_LINK", "REGRESSION_OF"];
     TAXONOMY_EDGES = ["IS_A"];
     TRIAGE_EDGES = ["TRIAGED_BY", "CONFIRMS", "INDICATES", "ROUTES_TO"];
     GIT_EDGES = ["POINTS_AT", "PARENT", "AUTHORED_BY"];
@@ -266,6 +266,10 @@ var init_castalia = __esm({
       // git topology, not signal-flow
       "AUTHORED_BY",
       // git authorship, not signal-flow
+      "PRODUCED",
+      // edit-episode provenance (Episode→symbol), not signal-flow — the family
+      // above was excluded together but this member slipped the net (LC-produced-pagerank);
+      // at 43% of all live edges it was the largest single edge population flowing rank
       "CONTRIBUTED",
       // agent attribution (Agent → knowledge), not signal-flow
       "SUPERSEDES",
@@ -273,8 +277,10 @@ var init_castalia = __esm({
       "ALTERNATIVE_TO",
       // symmetric peer marker — weight would let alternatives inflate each other
       // NB: BUILDS_ON is NOT excluded — it flows extension→base so foundational solutions rank up.
-      "SUSPECTED_LINK"
+      "SUSPECTED_LINK",
       // Somnus hypothesis (PLAN_SOMNUS_V2 §4) — never flows rank; navigation-invisible.
+      "REGRESSION_OF"
+      // recurrence marker (RG-recognize) — a question about a close, not signal-flow.
     ]);
     EDGE_WEIGHT = {
       // Causal — high signal
@@ -387,6 +393,7 @@ var init_castalia = __esm({
       ALTERNATIVE_TO: 0,
       // Suspicion — a hypothesis, weightless + PageRank-excluded (never flows rank / EIG).
       SUSPECTED_LINK: 0,
+      REGRESSION_OF: 0,
       // Git — topology/authorship, weightless (not domain signal-flow)
       POINTS_AT: 0,
       PARENT: 0,
@@ -417,6 +424,13 @@ var init_castalia = __esm({
   }
 });
 
+// ../../packages/shared/src/graph-events.ts
+var init_graph_events = __esm({
+  "../../packages/shared/src/graph-events.ts"() {
+    "use strict";
+  }
+});
+
 // ../../packages/shared/src/canonical/hash.ts
 import { createHash } from "node:crypto";
 function sha256(input) {
@@ -458,13 +472,18 @@ function resolveCanonical(label) {
 function resolveCanonicalId(label) {
   return resolveCanonical(label)?.id;
 }
+function resolveUnambiguousCanonicalId(label) {
+  const key = label.trim().toLowerCase();
+  if (AMBIGUOUS_ALIASES.has(key)) return void 0;
+  return resolveCanonicalId(key);
+}
 function aliasesLongestFirst() {
   const out2 = [];
   for (const e of REGISTRY) for (const a of e.aliases) out2.push({ alias: a.toLowerCase(), entity: e });
   out2.sort((x, y) => y.alias.length - x.alias.length);
   return out2;
 }
-var REGISTRY, BY_ALIAS;
+var REGISTRY, AMBIGUOUS_ALIASES, BY_ALIAS;
 var init_taxonomy = __esm({
   "../../packages/shared/src/nlp/taxonomy.ts"() {
     "use strict";
@@ -513,6 +532,13 @@ var init_taxonomy = __esm({
       { id: "concept:retry", name: "retry", category: "concept", aliases: ["retry"] },
       { id: "concept:migration", name: "migration", category: "concept", aliases: ["migration"] }
     ];
+    AMBIGUOUS_ALIASES = /* @__PURE__ */ new Set([
+      "node",
+      "go",
+      "pool",
+      "spring",
+      "ws"
+    ]);
     BY_ALIAS = /* @__PURE__ */ new Map();
     for (const e of REGISTRY) {
       for (const a of e.aliases) {
@@ -574,7 +600,7 @@ function lemma(token) {
   }
   return token;
 }
-function conceptTokens(text) {
+function tokenize(text, resolve) {
   const matches = text.normalize("NFC").toLowerCase().match(TOKEN_RE) ?? [];
   const out2 = /* @__PURE__ */ new Set();
   for (const raw of matches) {
@@ -584,11 +610,14 @@ function conceptTokens(text) {
       out2.add(token);
       continue;
     }
-    const canonical = resolveCanonicalId(token);
+    const canonical = resolve(token);
     out2.add(canonical ?? lemma(token));
   }
   return [...out2].sort();
 }
+function retrievalTokens(text) {
+  return tokenize(text, resolveUnambiguousCanonicalId);
+}
 var STOPWORDS, NEGATION_TOKENS, TOKEN_RE;
 var init_concept_bag = __esm({
   "../../packages/shared/src/nlp/concept-bag.ts"() {
@@ -15069,7 +15098,12 @@ var init_edge_rules = __esm({
       // ── Taxonomy (Track 4 Stream C: MITRE CWE `ChildOf` → `Weakness —IS_A→ Weakness`) ──
       IS_A: { from: ["Weakness"], to: ["Weakness"] },
       // ── Conceptual (v1 taxonomy.ts: instance → motif/pattern reference) ──
-      INSTANCE_OF: { to: ["Pattern", "Weakness", "Technique"] },
+      // `AntiPattern` joined the target set 2026-08-02: it is one of the three motif
+      // kinds (generalizer motifs.ts `layerOf`: pattern | technique | antipattern) and
+      // the SUPPRESSED-close path mints `Problem ─INSTANCE_OF→ AntiPattern` as the
+      // negative-knowledge binding ("silenced, not solved") — the original three-label
+      // rule predates AntiPattern joining the motif layer and silently ate that edge.
+      INSTANCE_OF: { to: ["Pattern", "AntiPattern", "Weakness", "Technique"] },
       IMPLEMENTS: { from: ["Solution", "Language", "Component"], to: ["Pattern", "Technique"] },
       MATCHES: { to: ["Pattern"] },
       // ── Artifact evidence (v1 taxonomy.ts artifact rows) ──
@@ -15179,6 +15213,14 @@ var init_wire = __esm({
        *  deployment a self-corroboration). Optional + additive: absent leaves the
        *  gate fail-open for that node, exactly today's behaviour. */
       originSession: external_exports.string().min(3).max(64).optional(),
+      /** Epoch ms of the ORIGINATING local node's creation — when the knowledge was
+       *  actually captured, as opposed to when its public twin reached the cloud.
+       *  Stored as `observedAt`; the network board's chronological view orders on
+       *  it. Without this the wire carried NO timestamp at all, so a node captured
+       *  days ago surfaced as "new" the moment it was generalized and published —
+       *  the board showed ingest order wearing a chronology's clothes. Optional +
+       *  additive: absent keeps ingest-time ordering for that node. */
+      originCreatedAtMs: external_exports.number().int().positive().optional(),
       extractionSource: external_exports.enum(INGEST_EXTRACTION_SOURCES),
       validationSource: external_exports.enum(VALIDATION_SOURCES).optional(),
       /** Org-membrane (M2): the daemon's anchor tag — it owns the lockfile, so it
@@ -15290,6 +15332,7 @@ var init_src = __esm({
   "../../packages/shared/src/index.ts"() {
     "use strict";
     init_castalia();
+    init_graph_events();
     init_identity();
     init_wire();
     init_edge_rules();
@@ -15351,6 +15394,51 @@ var init_review = __esm({
   }
 });
 
+// ../../packages/local-shared/src/anchorable.ts
+function anchorableExtensionAlternation() {
+  return BY_LENGTH.map((e) => e.slice(1).replace(/[+.]/g, (c) => `\\${c}`)).join("|");
+}
+var ANCHORABLE_EXTENSIONS, BY_LENGTH;
+var init_anchorable = __esm({
+  "../../packages/local-shared/src/anchorable.ts"() {
+    "use strict";
+    ANCHORABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+      // typescript provider
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      // python / go / rust / ruby / csharp providers
+      ".py",
+      ".go",
+      ".rs",
+      ".rb",
+      ".cs",
+      // cpp provider — every variant it parses, not just the three that were listed
+      ".c",
+      ".h",
+      ".cpp",
+      ".cc",
+      ".cxx",
+      ".c++",
+      ".hpp",
+      ".hh",
+      ".hxx",
+      ".h++",
+      // CUDA — the cpp provider parses these too. Missed when this list was first
+      // transcribed by hand; the parity test caught them on its very first run,
+      // which is the argument for the test existing.
+      ".cu",
+      ".cuh",
+      // no provider yet; the grammar ships. Inert, not wrong — see above.
+      ".java"
+    ]);
+    BY_LENGTH = [...ANCHORABLE_EXTENSIONS].sort((a, b) => b.length - a.length);
+  }
+});
+
 // ../../packages/local-shared/src/sqlite-adapter.ts
 function openDatabase(path) {
   const db = new DatabaseSync(path);
@@ -15363,6 +15451,7 @@ function openDatabase(path) {
       db.exec("PRAGMA journal_mode = WAL");
       db.exec("PRAGMA synchronous = NORMAL");
       db.exec("PRAGMA busy_timeout = 5000");
+      db.exec("PRAGMA journal_size_limit = 67108864");
     } catch {
     }
   }
@@ -15398,7 +15487,7 @@ function openDatabase(path) {
       return db.prepare(`PRAGMA ${key}`).get();
     },
     transaction(fn) {
-      db.exec("BEGIN");
+      db.exec("BEGIN IMMEDIATE");
       try {
         const r = fn();
         db.exec("COMMIT");
@@ -15452,10 +15541,92 @@ var init_src2 = __esm({
     init_profile();
     init_daemon_wire();
     init_review();
+    init_anchorable();
     init_sqlite_adapter();
   }
 });
 
+// ../../packages/indexer/src/parse-cache.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function parseCacheDir() {
+  return process.env["ERRATA_PARSE_CACHE"] ?? join(homedir(), ".errata", "parse-cache");
+}
+function parseCacheKey(source, providerId) {
+  return createHash2("sha256").update(`${PARSE_CACHE_VERSION}:${providerId}:${source}`).digest("hex");
+}
+function entryPath(dir, key) {
+  return join(dir, key.slice(0, 2), `${key.slice(2)}.json`);
+}
+function readParseCache(dir, key) {
+  const file2 = entryPath(dir, key);
+  try {
+    const raw = readFileSync(file2, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.v !== PARSE_CACHE_VERSION || !Array.isArray(parsed.symbols)) return null;
+    return { symbols: parsed.symbols, reExports: parsed.reExports ?? [] };
+  } catch {
+    return null;
+  }
+}
+function writeParseCache(dir, key, providerId, value) {
+  try {
+    const envelope = {
+      v: PARSE_CACHE_VERSION,
+      provider: providerId,
+      symbols: value.symbols,
+      reExports: value.reExports
+    };
+    const body2 = JSON.stringify(envelope);
+    if (body2.length > MAX_ENTRY_BYTES) return;
+    const file2 = entryPath(dir, key);
+    mkdirSync(join(dir, key.slice(0, 2)), { recursive: true });
+    writeFileSync(file2, body2);
+  } catch {
+  }
+}
+function sweepParseCacheOnce(dir, now = Date.now()) {
+  if (sweptThisProcess) return 0;
+  sweptThisProcess = true;
+  let removed = 0;
+  try {
+    if (!existsSync(dir)) return 0;
+    for (const bucket of readdirSync(dir)) {
+      const bucketDir = join(dir, bucket);
+      let names;
+      try {
+        names = readdirSync(bucketDir);
+      } catch {
+        continue;
+      }
+      for (const name2 of names) {
+        const file2 = join(bucketDir, name2);
+        try {
+          if (now - statSync(file2).mtimeMs > ENTRY_TTL_MS) {
+            rmSync(file2, { force: true });
+            removed++;
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return removed;
+}
+var PARSE_CACHE_VERSION, ENTRY_TTL_MS, MAX_ENTRY_BYTES, sweptThisProcess;
+var init_parse_cache = __esm({
+  "../../packages/indexer/src/parse-cache.ts"() {
+    "use strict";
+    PARSE_CACHE_VERSION = 1;
+    ENTRY_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+    MAX_ENTRY_BYTES = 2 * 1024 * 1024;
+    sweptThisProcess = false;
+  }
+});
+
 // ../../packages/indexer/src/simhash.ts
 function fnv1a64(s) {
   let h = FNV_OFFSET;
@@ -15474,7 +15645,7 @@ function popcount(x) {
   }
   return c;
 }
-function tokenize(text) {
+function tokenize2(text) {
   return text.match(/[A-Za-z_$][A-Za-z0-9_$]*|\d+|[^\s\w]/g) ?? [];
 }
 function shingle(tokens, n = SHINGLE_N) {
@@ -15503,7 +15674,7 @@ function simhashFeatures(features) {
   return out2;
 }
 function simhash(text) {
-  return simhashFeatures(shingle(tokenize(text)));
+  return simhashFeatures(shingle(tokenize2(text)));
 }
 function hammingDistance(a, b) {
   return popcount((a ^ b) & MASK64);
@@ -15679,10 +15850,10 @@ var init_identity2 = __esm({
 });
 
 // ../../packages/indexer/src/pipeline.ts
-import { appendFileSync, readFileSync, statSync } from "node:fs";
+import { appendFileSync, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
 import { readdir } from "node:fs/promises";
-import { extname, join, relative, sep } from "node:path";
-import { createHash as createHash2 } from "node:crypto";
+import { extname, join as join2, relative, sep } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
 import { execFileSync } from "node:child_process";
 function nowTs() {
   return indexNow ?? Date.now();
@@ -15691,7 +15862,7 @@ function fingerprintOf(signature, bodyHash) {
   return `${signature ?? ""}|${bodyHash ?? ""}`;
 }
 function sha(s) {
-  return createHash2("sha256").update(s).digest("hex").slice(0, 16);
+  return createHash3("sha256").update(s).digest("hex").slice(0, 16);
 }
 function fileNodeId(workspaceId, relPath) {
   return `file_${sha(workspaceId + ":" + relPath.replace(/\\/g, "/"))}`;
@@ -15811,10 +15982,11 @@ async function incrementalReindex(store2, rootPath, workspaceId, changedAbsPaths
     };
   }
   const fileHashes = /* @__PURE__ */ new Map();
+  const contentMovedPaths = /* @__PURE__ */ new Set();
   for (const rel of [...changedRelPaths]) {
     let h;
     try {
-      h = createHash2("sha256").update(readFileSync(join(rootPath, rel))).digest("hex");
+      h = createHash3("sha256").update(readFileSync2(join2(rootPath, rel))).digest("hex");
     } catch {
       continue;
     }
@@ -15823,6 +15995,8 @@ async function incrementalReindex(store2, rootPath, workspaceId, changedAbsPaths
     if (fnode && fnode.attrs["contentHash"] === h && !fileHasStrandedSymbol(store2, fnode.id)) {
       store2.updateNode(fnode.id, { lastUpdatedAt: t });
       changedRelPaths.delete(rel);
+    } else if (!fnode || fnode.attrs["contentHash"] !== h) {
+      contentMovedPaths.add(rel);
     }
   }
   if (changedRelPaths.size === 0) {
@@ -15861,13 +16035,13 @@ async function incrementalReindex(store2, rootPath, workspaceId, changedAbsPaths
   let parsedFiles = 0;
   for (const rel of changedRelPaths) {
     if (parsedFiles++ > 0) await new Promise((r2) => setImmediate(r2));
-    const abs = join(rootPath, ...rel.split("/"));
+    const abs = join2(rootPath, ...rel.split("/"));
     const ext = extname(abs).toLowerCase();
     const provider = providers.find((p) => p.fileExtensions.includes(ext));
     if (!provider) continue;
     let symbols;
     try {
-      symbols = provider.extractSymbols(readFileSync(abs, "utf8"), abs);
+      symbols = provider.extractSymbols(readFileSync2(abs, "utf8"), abs);
     } catch {
       continue;
     }
@@ -15957,6 +16131,7 @@ async function incrementalReindex(store2, rootPath, workspaceId, changedAbsPaths
     changedRelPaths
   });
   store2.transaction(() => {
+    store2.reviveReobserved([...changedRelPaths], workspaceId, t);
     const versionedAndFile = /* @__PURE__ */ new Set([...VERSIONED_LABELS, "File"]);
     const ownedLive = [];
     for (const n of store2.nodesByRelPath([...changedRelPaths])) {
@@ -16065,7 +16240,14 @@ async function incrementalReindex(store2, rootPath, workspaceId, changedAbsPaths
     const h = fileHashes.get(rel);
     if (!h) continue;
     const fnode = store2.getNode(fileNodeId(workspaceId, rel));
-    if (fnode) store2.updateNode(fnode.id, { attrs: { ...fnode.attrs, contentHash: h } });
+    if (!fnode) continue;
+    store2.updateNode(fnode.id, {
+      attrs: {
+        ...fnode.attrs,
+        contentHash: h,
+        ...contentMovedPaths.has(rel) ? { contentChangedAt: t } : {}
+      }
+    });
   }
   return {
     filesReindexed: changedRelPaths.size,
@@ -16113,8 +16295,13 @@ async function runIndexer(store2, opts) {
     byLanguage: {},
     durationMs: 0,
     nodesPurged: 0,
-    edgesPurged: 0
+    edgesPurged: 0,
+    parseCacheHits: 0,
+    parseCacheMisses: 0
   };
+  const cacheDir = parseCacheDir();
+  const parseCacheEnabled = cacheDir !== "";
+  if (parseCacheEnabled) sweepParseCacheOnce(cacheDir);
   if (opts.clean) {
     const purge = purgeWorkspaceCodeGraph(store2, opts.workspaceId);
     report.nodesPurged = purge.nodes;
@@ -16168,25 +16355,38 @@ async function runIndexer(store2, opts) {
     }
     let source;
     try {
-      const st = statSync(f.absPath);
+      const st = statSync2(f.absPath);
       if (st.size > maxBytes) {
         report.filesSkipped++;
         continue;
       }
-      source = readFileSync(f.absPath, "utf8");
+      source = readFileSync2(f.absPath, "utf8");
     } catch {
       report.filesSkipped++;
       continue;
     }
+    const cacheKey = parseCacheKey(source, f.provider.id);
+    const cached2 = parseCacheEnabled ? readParseCache(cacheDir, cacheKey) : null;
     let symbols;
-    try {
-      symbols = f.provider.extractSymbols(source, f.absPath);
-    } catch {
-      report.filesSkipped++;
-      continue;
+    let reExports;
+    if (cached2) {
+      symbols = cached2.symbols;
+      reExports = cached2.reExports;
+      report.parseCacheHits++;
+    } else {
+      try {
+        symbols = f.provider.extractSymbols(source, f.absPath);
+      } catch {
+        report.filesSkipped++;
+        continue;
+      }
+      reExports = scanReExports(source);
+      report.parseCacheMisses++;
+      if (parseCacheEnabled) {
+        writeParseCache(cacheDir, cacheKey, f.provider.id, { symbols, reExports });
+      }
     }
     symbolsByFile.set(f.relPath, symbols);
-    const reExports = scanReExports(source);
     if (reExports.length > 0) reExportsByFile.set(f.relPath, reExports);
     report.filesParsed++;
     report.byLanguage[f.provider.id] = (report.byLanguage[f.provider.id] ?? 0) + 1;
@@ -16231,7 +16431,7 @@ async function runIndexer(store2, opts) {
     const depth = fileNode.relPath.split("/").length;
     if (depth !== 3) continue;
     try {
-      const pkg = JSON.parse(readFileSync(fileNode.absPath, "utf8"));
+      const pkg = JSON.parse(readFileSync2(fileNode.absPath, "utf8"));
       if (!pkg.name) continue;
       const pkgDir = fileNode.relPath.replace(/\/package\.json$/, "");
       const candidates = [
@@ -16613,7 +16813,7 @@ async function scan(root, current, ignores, providers, out2) {
   for (const ent of entries) {
     if (ignores.has(ent.name)) continue;
     if (ent.name.startsWith(".") && ent.name !== ".") continue;
-    const abs = join(current, ent.name);
+    const abs = join2(current, ent.name);
     if (ent.isDirectory()) {
       await scan(root, abs, ignores, providers, out2);
     } else if (ent.isFile()) {
@@ -16622,7 +16822,7 @@ async function scan(root, current, ignores, providers, out2) {
       const rel = relative(root, abs).split(sep).join("/");
       let size = 0;
       try {
-        size = statSync(abs).size;
+        size = statSync2(abs).size;
       } catch {
         continue;
       }
@@ -16636,7 +16836,7 @@ async function scan(root, current, ignores, providers, out2) {
     }
   }
 }
-function gitListFiles(root, ignores, providers) {
+function gitListRelPaths(root, ignores) {
   let stdout;
   try {
     stdout = execFileSync(
@@ -16659,10 +16859,19 @@ function gitListFiles(root, ignores, providers) {
     if (segs.some((s) => ignores.has(s) || s.startsWith(".") && s.length > 1)) {
       continue;
     }
-    const abs = join(root, rel);
+    out2.push(rel);
+  }
+  return out2;
+}
+function gitListFiles(root, ignores, providers) {
+  const rels = gitListRelPaths(root, ignores);
+  if (rels === null) return null;
+  const out2 = [];
+  for (const rel of rels) {
+    const abs = join2(root, rel);
     let size;
     try {
-      size = statSync(abs).size;
+      size = statSync2(abs).size;
     } catch {
       continue;
     }
@@ -16682,7 +16891,7 @@ function upsertFile(store2, id, f, workspaceId) {
   const now = nowTs();
   let contentHash;
   try {
-    contentHash = createHash2("sha256").update(readFileSync(f.absPath)).digest("hex");
+    contentHash = createHash3("sha256").update(readFileSync2(f.absPath)).digest("hex");
   } catch {
   }
   const node = {
@@ -16881,6 +17090,7 @@ var init_pipeline = __esm({
   "../../packages/indexer/src/pipeline.ts"() {
     "use strict";
     init_src2();
+    init_parse_cache();
     init_identity2();
     DEFAULT_IGNORES = /* @__PURE__ */ new Set([
       "node_modules",
@@ -21045,8 +21255,8 @@ ${JSON.stringify(symbolNames, null, 2)}`);
 
 // ../../packages/indexer/src/languages/tree-sitter-loader.ts
 import { fileURLToPath } from "node:url";
-import { dirname, join as join2 } from "node:path";
-import { existsSync, readdirSync } from "node:fs";
+import { dirname, join as join3 } from "node:path";
+import { existsSync as existsSync2, readdirSync as readdirSync2 } from "node:fs";
 import { createRequire } from "node:module";
 function entryDir() {
   try {
@@ -21060,27 +21270,27 @@ function entryDir() {
 }
 function findWasmDir() {
   const here = entryDir();
-  const seaWasm = join2(here, "resources", "wasm");
-  if (existsSync(join2(seaWasm, "tree-sitter-typescript.wasm"))) return seaWasm;
+  const seaWasm = join3(here, "resources", "wasm");
+  if (existsSync2(join3(seaWasm, "tree-sitter-typescript.wasm"))) return seaWasm;
   let dir = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const flat = join2(
+    const flat = join3(
       dir,
       "node_modules",
       "@vscode",
       "tree-sitter-wasm",
       "wasm"
     );
-    if (existsSync(join2(flat, "tree-sitter-typescript.wasm"))) return flat;
+    if (existsSync2(join3(flat, "tree-sitter-typescript.wasm"))) return flat;
     dir = dirname(dir);
   }
   let root = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const pnpmDir = join2(root, "node_modules", ".pnpm");
-    if (existsSync(pnpmDir)) {
-      for (const entry of readdirSync(pnpmDir)) {
+    const pnpmDir = join3(root, "node_modules", ".pnpm");
+    if (existsSync2(pnpmDir)) {
+      for (const entry of readdirSync2(pnpmDir)) {
         if (entry.startsWith("@vscode+tree-sitter-wasm@")) {
-          const candidate = join2(
+          const candidate = join3(
             pnpmDir,
             entry,
             "node_modules",
@@ -21088,7 +21298,7 @@ function findWasmDir() {
             "tree-sitter-wasm",
             "wasm"
           );
-          if (existsSync(join2(candidate, "tree-sitter-typescript.wasm"))) {
+          if (existsSync2(join3(candidate, "tree-sitter-typescript.wasm"))) {
             return candidate;
           }
         }
@@ -21102,27 +21312,27 @@ function findWasmDir() {
 }
 function findRuntimeDir() {
   const here = entryDir();
-  const seaRuntime = join2(here, "resources", "wasm");
-  if (existsSync(join2(seaRuntime, "web-tree-sitter.wasm"))) return seaRuntime;
+  const seaRuntime = join3(here, "resources", "wasm");
+  if (existsSync2(join3(seaRuntime, "web-tree-sitter.wasm"))) return seaRuntime;
   let dir = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const flat = join2(dir, "node_modules", "web-tree-sitter");
-    if (existsSync(join2(flat, "web-tree-sitter.wasm"))) return flat;
+    const flat = join3(dir, "node_modules", "web-tree-sitter");
+    if (existsSync2(join3(flat, "web-tree-sitter.wasm"))) return flat;
     dir = dirname(dir);
   }
   let root = here;
   for (let i2 = 0; i2 < 6; i2++) {
-    const pnpmDir = join2(root, "node_modules", ".pnpm");
-    if (existsSync(pnpmDir)) {
-      for (const entry of readdirSync(pnpmDir)) {
+    const pnpmDir = join3(root, "node_modules", ".pnpm");
+    if (existsSync2(pnpmDir)) {
+      for (const entry of readdirSync2(pnpmDir)) {
         if (entry.startsWith("web-tree-sitter@")) {
-          const candidate = join2(
+          const candidate = join3(
             pnpmDir,
             entry,
             "node_modules",
             "web-tree-sitter"
           );
-          if (existsSync(join2(candidate, "web-tree-sitter.wasm"))) {
+          if (existsSync2(join3(candidate, "web-tree-sitter.wasm"))) {
             return candidate;
           }
         }
@@ -21139,7 +21349,7 @@ async function loadWebTreeSitter() {
     void err2;
   }
   const here = entryDir();
-  const seaResourceBase = join2(here, "resources", "_resolve.js");
+  const seaResourceBase = join3(here, "resources", "_resolve.js");
   const resourceRequire = createRequire(seaResourceBase);
   return resourceRequire("web-tree-sitter");
 }
@@ -21154,9 +21364,9 @@ async function ensureTreeSitterReady() {
     await Parser2.init({
       locateFile: (name2) => {
         if (name2 === "tree-sitter.wasm" || name2 === "web-tree-sitter.wasm") {
-          return join2(runtime, name2);
+          return join3(runtime, name2);
         }
-        return join2(grammars, name2);
+        return join3(grammars, name2);
       }
     });
   })();
@@ -21168,7 +21378,7 @@ async function loadGrammar(name2) {
   if (cached2) return cached2;
   if (!languageClass) throw new Error("tree-sitter not initialized");
   const grammars = findWasmDir();
-  const lang = await languageClass.load(join2(grammars, `${name2}.wasm`));
+  const lang = await languageClass.load(join3(grammars, `${name2}.wasm`));
   grammarCache.set(name2, lang);
   return lang;
 }
@@ -21191,7 +21401,7 @@ var init_tree_sitter_loader = __esm({
 });
 
 // ../../packages/indexer/src/languages/typescript-treesitter.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 function extractNode(node, source, containerQname, containerKind) {
   switch (node.type) {
     case "function_declaration":
@@ -21404,7 +21614,7 @@ function scopeRecord(kind, name2, qname, node, body2, source) {
       const sig = header.replace(/\s+/g, " ").trim();
       if (sig) rec.signature = sig;
       const bodyText = source.slice(body2.startIndex, body2.endIndex);
-      rec.bodyHash = createHash3("sha256").update(bodyText).digest("hex").slice(0, 16);
+      rec.bodyHash = createHash4("sha256").update(bodyText).digest("hex").slice(0, 16);
       rec.bodySimhash = toHex(simhash(bodyText));
     }
   }
@@ -21846,14 +22056,14 @@ var init_typescript_treesitter = __esm({
 });
 
 // ../../packages/indexer/src/languages/python-treesitter.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function sigAndHash(node, body2, source) {
   if (!body2) return {};
   const out2 = {};
   const sig = source.slice(node.startIndex, body2.startIndex).replace(/\s+/g, " ").trim();
   if (sig) out2.signature = sig;
   const bodyText = source.slice(body2.startIndex, body2.endIndex);
-  out2.bodyHash = createHash4("sha256").update(bodyText).digest("hex").slice(0, 16);
+  out2.bodyHash = createHash5("sha256").update(bodyText).digest("hex").slice(0, 16);
   out2.bodySimhash = toHex(simhash(bodyText));
   return out2;
 }
@@ -22266,7 +22476,7 @@ var init_python_treesitter = __esm({
 });
 
 // ../../packages/indexer/src/languages/cpp-treesitter.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 function extractNode3(node, containerQname, containerIsClass, source) {
   switch (node.type) {
     case "function_definition":
@@ -22450,7 +22660,7 @@ function sigAndHash2(node, body2, source) {
   const sig = source.slice(node.startIndex, body2.startIndex).replace(/\s+/g, " ").trim();
   if (sig) out2.signature = sig;
   const bodyText = source.slice(body2.startIndex, body2.endIndex);
-  out2.bodyHash = createHash5("sha256").update(bodyText).digest("hex").slice(0, 16);
+  out2.bodyHash = createHash6("sha256").update(bodyText).digest("hex").slice(0, 16);
   out2.bodySimhash = toHex(simhash(bodyText));
   return out2;
 }
@@ -22611,7 +22821,7 @@ var init_cpp_treesitter = __esm({
 });
 
 // ../../packages/indexer/src/languages/go-treesitter.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 function extractNode4(node, containerQname, source) {
   switch (node.type) {
     case "function_declaration": {
@@ -22773,7 +22983,7 @@ function sigAndHash3(node, body2, source) {
   const sig = source.slice(node.startIndex, body2.startIndex).replace(/\s+/g, " ").trim();
   if (sig) out2.signature = sig;
   const bodyText = source.slice(body2.startIndex, body2.endIndex);
-  out2.bodyHash = createHash6("sha256").update(bodyText).digest("hex").slice(0, 16);
+  out2.bodyHash = createHash7("sha256").update(bodyText).digest("hex").slice(0, 16);
   out2.bodySimhash = toHex(simhash(bodyText));
   return out2;
 }
@@ -22917,7 +23127,7 @@ var init_go_treesitter = __esm({
 });
 
 // ../../packages/indexer/src/languages/rust-treesitter.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 function extractNode5(node, containerQname, containerIsClass, source) {
   switch (node.type) {
     case "function_item":
@@ -23132,7 +23342,7 @@ function sigAndHash4(node, body2, source) {
   const sig = source.slice(node.startIndex, body2.startIndex).replace(/\s+/g, " ").trim();
   if (sig) out2.signature = sig;
   const bodyText = source.slice(body2.startIndex, body2.endIndex);
-  out2.bodyHash = createHash7("sha256").update(bodyText).digest("hex").slice(0, 16);
+  out2.bodyHash = createHash8("sha256").update(bodyText).digest("hex").slice(0, 16);
   out2.bodySimhash = toHex(simhash(bodyText));
   return out2;
 }
@@ -23283,7 +23493,7 @@ var init_rust_treesitter = __esm({
 });
 
 // ../../packages/indexer/src/languages/ruby-treesitter.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 function sigAndHash5(node, body2, source) {
   if (!body2) {
     const sig2 = source.slice(node.startIndex, node.endIndex).replace(/\s+/g, " ").trim();
@@ -23293,7 +23503,7 @@ function sigAndHash5(node, body2, source) {
   const sig = source.slice(node.startIndex, body2.startIndex).replace(/\s+/g, " ").trim();
   if (sig) out2.signature = sig;
   const bodyText = source.slice(body2.startIndex, body2.endIndex);
-  out2.bodyHash = createHash8("sha256").update(bodyText).digest("hex").slice(0, 16);
+  out2.bodyHash = createHash9("sha256").update(bodyText).digest("hex").slice(0, 16);
   out2.bodySimhash = toHex(simhash(bodyText));
   return out2;
 }
@@ -23639,7 +23849,7 @@ var init_ruby_treesitter = __esm({
 });
 
 // ../../packages/indexer/src/languages/csharp-treesitter.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 function extractNode7(node, containerQname, containerIsType, source, eof) {
   switch (node.type) {
     case "method_declaration":
@@ -23841,7 +24051,7 @@ function sigAndHash6(node, body2, source) {
   const sig = source.slice(node.startIndex, body2.startIndex).replace(/\s+/g, " ").trim();
   if (sig) out2.signature = sig;
   const bodyText = source.slice(body2.startIndex, body2.endIndex);
-  out2.bodyHash = createHash9("sha256").update(bodyText).digest("hex").slice(0, 16);
+  out2.bodyHash = createHash10("sha256").update(bodyText).digest("hex").slice(0, 16);
   out2.bodySimhash = toHex(simhash(bodyText));
   return out2;
 }
@@ -23998,6 +24208,7 @@ var init_csharp_treesitter = __esm({
 // ../../packages/indexer/src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  DEFAULT_IGNORES: () => DEFAULT_IGNORES,
   DRIFT_FORK_RATIO: () => DRIFT_FORK_RATIO,
   TreeSitterCSharpProvider: () => TreeSitterCSharpProvider,
   TreeSitterCppProvider: () => TreeSitterCppProvider,
@@ -24014,6 +24225,7 @@ __export(src_exports, {
   findInnermostScope: () => findInnermostScope,
   folderNodeId: () => folderNodeId,
   fromHex: () => fromHex,
+  gitListRelPaths: () => gitListRelPaths,
   hammingDistance: () => hammingDistance,
   hasForkedDrift: () => hasForkedDrift,
   incrementalReindex: () => incrementalReindex,
@@ -24026,7 +24238,7 @@ __export(src_exports, {
   simhashFeatures: () => simhashFeatures,
   symbolNodeId: () => symbolNodeId,
   toHex: () => toHex,
-  tokenize: () => tokenize
+  tokenize: () => tokenize2
 });
 function defaultProviders() {
   if (providersCache) return providersCache;
@@ -24079,9 +24291,38 @@ var LOCAL_RULE_OVERRIDES = {
     to: [...CODE_NODE_LABELS, "Symbol"]
   },
   REVEALED_BY: null,
-  PRODUCED: null
+  PRODUCED: null,
+  // FIXED_BY locally ALSO carries the fix-provenance sense: `resolveProblem`
+  // attributes a closed Problem to the fixing `Episode` (PLAN_PLASTICITY §2.1)
+  // alongside the cloud's Problem→Solution knowledge claim. Same shape as
+  // PRODUCED/REVEALED_BY above — an Episode is code-layer and never drains, so
+  // the cloud door's `to: [Solution]` rule is untouched. The `from` constraint
+  // stays: the reversed (Solution)-FIXED_BY->(...) splash bug is the reason
+  // this rule exists at all.
+  FIXED_BY: { from: EDGE_RULES["FIXED_BY"]?.from, to: ["Solution", "Episode"] },
+  // RG-recognize: a NEW open Problem re-observing a RESOLVED one ("this is
+  // back — the fix didn't hold"). Local-only for now: the instance drain's
+  // INSTANCE_EDGES allowlist doesn't ship it, and the cloud door's matrix
+  // doesn't know it — crossing the membrane is a deliberate later step, never
+  // a side effect (the half-shipped-edge-type lesson).
+  REGRESSION_OF: { from: ["Problem"], to: ["Problem"] }
 };
-var SCHEMA_VERSION = 5;
+function localEdgeViolation(fromLabel, type, toLabel) {
+  if (type in LOCAL_RULE_OVERRIDES) {
+    const rule = LOCAL_RULE_OVERRIDES[type];
+    if (!rule) return null;
+    if (fromLabel && rule.from && !rule.from.includes(fromLabel)) {
+      return `${type} cannot originate from ${fromLabel} locally (allowed: ${rule.from.join(", ")})`;
+    }
+    if (toLabel && rule.to && !rule.to.includes(toLabel)) {
+      return `${type} cannot target ${toLabel} locally (allowed: ${rule.to.join(", ")})`;
+    }
+    return null;
+  }
+  const verdict = isValidEdge(fromLabel, type, toLabel);
+  return verdict.ok ? null : verdict.reason ?? "edge rule violation";
+}
+var SCHEMA_VERSION = 6;
 var SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS schema_version (
   version INTEGER PRIMARY KEY
@@ -24096,6 +24337,21 @@ CREATE TABLE IF NOT EXISTS store_meta (
   value TEXT NOT NULL
 );
 
+-- Durable ledger of edges the ontology gate REFUSED, keyed by edge type.
+-- Durable rather than in-memory for one specific reason: the status command runs
+-- in a SEPARATE process and opens its own store handle, so a counter living on
+-- the instance reads 0 there forever. That is exactly how a producer rejecting
+-- 100% of its output stayed invisible for 17 days. Persisting it also survives
+-- the daemon restart that would otherwise erase the evidence.
+-- Keyed by type because a systematic producer bug shows up as ONE type
+-- dominating; sample keeps the latest reason so the count is actionable.
+CREATE TABLE IF NOT EXISTS edge_rejections (
+  type TEXT PRIMARY KEY,
+  count INTEGER NOT NULL DEFAULT 0,
+  last_at INTEGER NOT NULL,
+  sample TEXT
+);
+
 CREATE TABLE IF NOT EXISTS nodes (
   id TEXT PRIMARY KEY,
   label TEXT NOT NULL,
@@ -24472,6 +24728,16 @@ var SqliteGraphStore = class {
           if (!cols.has(name2)) this.db.exec(ddl);
         }
       }
+      if (from < 6) {
+        this.db.exec(`
+          CREATE TABLE IF NOT EXISTS edge_rejections (
+            type TEXT PRIMARY KEY,
+            count INTEGER NOT NULL DEFAULT 0,
+            last_at INTEGER NOT NULL,
+            sample TEXT
+          )
+        `);
+      }
       this.db.prepare("UPDATE schema_version SET version = ?").run(SCHEMA_VERSION);
     });
   }
@@ -24553,6 +24819,7 @@ var SqliteGraphStore = class {
     const violation = this.edgeRuleViolation(edge);
     if (violation) {
       this.rejectedEdgeCount++;
+      this.recordEdgeRejection(edge.type, violation, edge.lastSeenAt || edge.createdAt || 0);
       console.warn(`[local-graph] rejected edge ${edge.from}-[:${edge.type}]->${edge.to}: ${violation}`);
       return;
     }
@@ -24577,22 +24844,51 @@ var SqliteGraphStore = class {
    *  overlay consulted first. Returns the reason string on a documented-
    *  forbidden combination, else null. Point lookups on the id PK — negligible
    *  next to the insert itself. */
-  edgeRuleViolation(edge) {
-    const fromLabel = this.getNode(edge.from)?.label;
-    const toLabel = this.getNode(edge.to)?.label;
-    if (edge.type in LOCAL_RULE_OVERRIDES) {
-      const rule = LOCAL_RULE_OVERRIDES[edge.type];
-      if (!rule) return null;
-      if (fromLabel && rule.from && !rule.from.includes(fromLabel)) {
-        return `${edge.type} cannot originate from ${fromLabel} locally (allowed: ${rule.from.join(", ")})`;
-      }
-      if (toLabel && rule.to && !rule.to.includes(toLabel)) {
-        return `${edge.type} cannot target ${toLabel} locally (allowed: ${rule.to.join(", ")})`;
-      }
-      return null;
+  /** Upsert one refusal into the durable ledger. Best-effort: a bookkeeping
+   *  failure must never turn a refused edge into a thrown write. */
+  recordEdgeRejection(type, reason, at) {
+    try {
+      this.db.prepare(
+        `INSERT INTO edge_rejections (type, count, last_at, sample) VALUES (?, 1, ?, ?)
+           ON CONFLICT(type) DO UPDATE SET
+             count = count + 1, last_at = excluded.last_at, sample = excluded.sample`
+      ).run(type, at, reason.slice(0, 200));
+    } catch {
     }
-    const verdict = isValidEdge(fromLabel, edge.type, toLabel);
-    return verdict.ok ? null : verdict.reason ?? "edge rule violation";
+  }
+  /** Refusals recorded by the ontology gate, per edge type, newest activity first.
+   *  Durable across restarts and readable from any process (see the table note). */
+  edgeRejections() {
+    try {
+      return this.db.prepare(
+        "SELECT type, count, last_at AS lastAt, sample FROM edge_rejections ORDER BY count DESC, last_at DESC"
+      ).all();
+    } catch {
+      return [];
+    }
+  }
+  /** Drop ledger entries whose last refusal predates `cutoff`. A still-misbehaving
+   *  producer keeps refreshing `last_at` and survives; a fixed one fades out. */
+  pruneEdgeRejections(cutoff) {
+    try {
+      this.db.prepare("DELETE FROM edge_rejections WHERE last_at < ?").run(cutoff);
+    } catch {
+    }
+  }
+  /** Clear the ledger outright, whole or per type — operator escape hatch. */
+  clearEdgeRejections(type) {
+    try {
+      if (type) this.db.prepare("DELETE FROM edge_rejections WHERE type = ?").run(type);
+      else this.db.exec("DELETE FROM edge_rejections");
+    } catch {
+    }
+  }
+  edgeRuleViolation(edge) {
+    return localEdgeViolation(
+      this.getNode(edge.from)?.label,
+      edge.type,
+      this.getNode(edge.to)?.label
+    );
   }
   updateEdge(id, patch) {
     this.stmts.updateEdge.run({
@@ -24729,6 +25025,163 @@ var SqliteGraphStore = class {
     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 });
+  }
+  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);
+  }
+  /** 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");
+  }
+  /** 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;
+  }
+  /** 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;
+  }
+  checkpointWal() {
+    try {
+      const r = this.db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+      return r ?? null;
+    } catch {
+      return null;
+    }
+  }
+  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;
+  }
+  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) };
+  }
+  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;
+  }
+  /**
+   * 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
+    }));
+  }
   /** 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. */
@@ -24749,6 +25202,10 @@ var SqliteGraphStore = class {
     if (!live) return null;
     const version2 = live.version ?? 1;
     const frozenId = `${liveId}@v${version2}`;
+    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}`,
@@ -24807,6 +25264,7 @@ var CAUSAL_FAMILY = [
 
 // ../../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 };
@@ -24829,13 +25287,72 @@ function addDependency(store2, opts) {
   store2.mergeEdge(edge);
   return edge;
 }
-function markRevisit(store2, node, reason, ts) {
+function markRevisit(store2, node, reason, ts, answeredWhen) {
   const fresh = store2.getNode(node.id) ?? node;
   store2.updateNode(node.id, {
-    attrs: { ...fresh.attrs, revisit: true, revisitReason: reason, revisitSinceTs: ts },
+    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";
+  }
+  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 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;
+    }
+  }
+}
+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.nodesAsOf(asOf).filter((n) => n.attrs["revisit"] === true).map((n) => ({
     id: n.id,
@@ -24968,7 +25485,6 @@ function markBoth(store2, a, b, patch, ts) {
 // ../../packages/local-graph/src/design-problem.ts
 init_src();
 init_src();
-init_src2();
 
 // ../../packages/local-graph/src/problem-package-link.ts
 init_src();
@@ -25154,46 +25670,109 @@ function backfillProblemContext(store2, ts) {
 }
 
 // ../../packages/local-graph/src/design-problem.ts
-function isConstraintProblem(node) {
-  return node.attrs["kind"] === "constraint";
+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"
+];
+function corroborations(n) {
+  return Number(n.attrs["corroborations"] ?? 0);
 }
-function buildNode(id, label, description, ts, attrs) {
-  return {
-    id,
-    label,
-    description,
-    extractionConfidence: 0.4,
-    // provisional: below the error-path's 0.6+
-    extractionSource: "agent-observed",
-    embedding: [],
-    cumulativeSurprise: 0,
-    peakSurprise: 0,
-    cumulativeHits: 1,
-    lastUpdatedAt: ts,
-    createdAt: ts,
-    memoryTier: "short-term",
-    pageRank: 0,
-    isLandmark: false,
-    community: null,
-    stability: "unstable",
-    attrs
-  };
+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 mergeEdge(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",
-    createdAt: ts,
-    lastSeenAt: ts,
-    navSuccesses: 0,
-    navFailures: 0,
-    attrs: { provisional: true }
+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
+function isConstraintProblem(node) {
+  return node.attrs["kind"] === "constraint";
 }
+var RECURRENCE_DEBOUNCE_MS = 60 * 60 * 1e3;
 var CITABLE_PRIOR_LABELS = /* @__PURE__ */ new Set([
   "Solution",
   "RootCause",
@@ -25201,6 +25780,9 @@ var CITABLE_PRIOR_LABELS = /* @__PURE__ */ new Set([
   "Technique",
   "AntiPattern"
 ]);
+function isAutoMinted(n) {
+  return n.label === "Solution" && String(n.description ?? "").startsWith(AUTO_MINT_PREFIX);
+}
 function priorsForFile(store2, relPath) {
   const want = relPath.trim().replace(/^\.?\//, "");
   let file2 = null;
@@ -25213,37 +25795,52 @@ function priorsForFile(store2, relPath) {
   if (!file2) return null;
   const openProblems = [];
   const constraints = [];
+  const resolvedProblems = [];
   const seenProblem = /* @__PURE__ */ new Set();
   const related = /* @__PURE__ */ new Map();
   for (const e of store2.inEdges(file2.id, ["ANCHORED_AT"])) {
     const n = store2.getNode(e.from);
     if (!n) continue;
     if (n.label === "Problem") {
-      if (!n.attrs["resolvedAt"] && !seenProblem.has(n.id)) {
-        seenProblem.add(n.id);
+      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)) {
+    } 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]) {
+  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)) related.set(n.id, n);
-      if (n && n.label === "Solution" && e.type === "SOLVED_BY") {
+      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 && related.size === 0) return null;
+  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);
-  return { file: file2, openProblems, constraints, related: [...related.values()], solutionsByProblem };
+  resolvedProblems.sort(
+    (a, b) => Number(b.attrs["resolvedAt"] ?? 0) - Number(a.attrs["resolvedAt"] ?? 0)
+  );
+  return {
+    file: file2,
+    openProblems,
+    constraints,
+    resolvedProblems,
+    related: [...related.values()],
+    solutionsByProblem
+  };
 }
 function recordAnchorHint(store2, problemId, relPath, provenance, ts) {
   const p = store2.getNode(problemId);
@@ -25254,8 +25851,34 @@ function recordAnchorHint(store2, problemId, relPath, provenance, ts) {
   });
   return true;
 }
+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) 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 report;
+}
 var AUTO_MINT_PREFIX = "addressed by an edit to ";
-function resolveDesignProblems(store2, t) {
+function markFixCandidates(store2, t) {
   let resolved = 0;
   for (const p of store2.findNodesByLabel("Problem")) {
     if (!p.id.startsWith("dprob_")) continue;
@@ -25264,10 +25887,13 @@ function resolveDesignProblems(store2, t) {
     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);
-      if (sym && sym.lastUpdatedAt > p.createdAt) {
+      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;
@@ -25275,35 +25901,182 @@ function resolveDesignProblems(store2, t) {
       }
     }
     if (!edited) continue;
-    if (store2.outEdges(p.id, ["SOLVED_BY"]).length === 0) {
-      const solId = `dfix_${digest({ problemId: p.id, edit: t })}`.slice(0, 56);
-      store2.mergeNode(
-        buildNode(solId, "Solution", `${AUTO_MINT_PREFIX}${symName}`, t, {
-          source: "convo",
-          provisional: false,
-          // AC-resolution-attrs: the resolving symbol/file as STRUCTURED data, not
-          // just prose — the F2 join key downstream backfills and the viz read.
-          resolvedSymbols: [symName],
-          ...symRelPath ? { resolvedRelPath: symRelPath } : {}
-        })
-      );
-      mergeEdge(store2, p.id, solId, "SOLVED_BY", t);
-      for (const ae of store2.outEdges(p.id, ["ANCHORED_AT"]))
-        mergeEdge(store2, solId, ae.to, "ANCHORED_AT", t);
-    }
+    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, provisional: false, resolvedAt: t },
+      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)
+      },
       lastUpdatedAt: t
     });
     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, lastUpdatedAt: t });
+    if (answered) report.answered++;
+    else if (ignored) report.ignored++;
+    else report.unsubstantiated++;
+  }
+  return report;
+}
+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/local-graph/src/intent.ts
+init_src();
 
 // ../../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 repairLegacyAnchorsFromStatement(store2, ts) {
+  const report = {
+    repaired: [],
+    retiredGuesses: 0,
+    noPathNamed: 0,
+    pathUnknown: 0,
+    alreadyCorrect: 0
+  };
+  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 });
+  }
+  const resolvePath = (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;
+  };
+  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({
+        id: `edge_${digest({ from: p.id, type: "ANCHORED_AT", to: target.id })}`.slice(0, 24),
+        from: p.id,
+        to: target.id,
+        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: guessedPaths[0] ?? "",
+          restatedAt: 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 {
+    }
+  }
+  return report;
+}
 function backfillLegacyAnchors(store2, ts) {
   const report = {
     demotedEdges: 0,
@@ -25343,7 +26116,11 @@ function backfillLegacyAnchors(store2, ts) {
           store2,
           sol,
           `auto-closed off a pre-provenance anchor (guessed ${guessedAnchor}) \u2014 confirm the problem is really fixed, or reopen it`,
-          ts
+          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 },
@@ -25377,7 +26154,7 @@ function pagerank(input) {
   const ids = input.nodeIds;
   const n = ids.length;
   if (n === 0) {
-    return { scores: /* @__PURE__ */ new Map(), iterations: 0, converged: true };
+    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);
@@ -25449,8 +26226,12 @@ function pagerank(input) {
     }
   }
   const scores = /* @__PURE__ */ new Map();
-  for (let i2 = 0; i2 < n; i2++) scores.set(ids[i2], score2[i2]);
-  return { scores, iterations: iter, converged };
+  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()];
@@ -25460,7 +26241,7 @@ function markLandmarks(scores, percentile = 0.1, filter) {
     }
   }
   if (entries.length === 0) return /* @__PURE__ */ new Set();
-  entries.sort((a, b) => b[1] - a[1]);
+  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++) {
@@ -25698,8 +26479,86 @@ function motifDecision(input) {
   };
 }
 
-// ../../packages/local-graph/src/community.ts
-init_src2();
+// ../../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/triage.ts
 init_src();
@@ -25708,96 +26567,8 @@ init_src();
 init_src2();
 var DRIFT_VALUES = new Set(Object.values(DRIFT_KIND));
 
-// ../../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"
-];
-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(conceptTokens(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);
-  store2.updateNode(survivor.id, {
-    attrs: {
-      ...surv.attrs,
-      sources: [...sources],
-      corroborations: corroborations(surv) + corroborations(dup) + 1
-    },
-    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/community.ts
+init_src2();
 
 // ../../packages/local-graph/src/tools.ts
 init_src();
@@ -25814,6 +26585,9 @@ function rankToolsForHandles(store2, limit = 5) {
 // ../../packages/local-graph/src/principle-sync.ts
 init_src2();
 
+// ../../packages/local-graph/src/mechanism-liveness.ts
+var STALL_MIN_SPAN_MS = 60 * 60 * 1e3;
+
 // ../../packages/generalizer/src/generalizer.ts
 init_src2();
 init_src();
@@ -25933,7 +26707,164 @@ function promoteMotifs(store2, t) {
 }
 
 // ../../packages/generalizer/src/nightly.ts
-function runNightlyPipeline(store2) {
+var FULL_RESCORE_EVERY = 12;
+var INCREMENTAL_REGION_MAX_FRACTION = 0.2;
+var INCREMENTAL_HOPS = 3;
+function runGraphRescore(store2, opts = {}) {
+  const lastRescoreAt = Number(store2.getMeta?.("lastRescoreAt") ?? 0);
+  const sinceFull = Number(store2.getMeta?.("rescoresSinceFull") ?? 0);
+  const incrementalCapable = !opts.forceFull && lastRescoreAt > 0 && sinceFull < FULL_RESCORE_EVERY - 1 && !!store2.getMeta && !!store2.setMeta && !!store2.dirtyNodeIdsSince && !!store2.edgeEndpointsTouchedSince && !!store2.outEdgesForMany && !!store2.inEdgesForMany && !!store2.ranksForMany && !!store2.landmarkSweepRows;
+  if (incrementalCapable) {
+    const started = Date.now();
+    const inc = tryIncrementalRescore(store2, lastRescoreAt, started);
+    if (inc) {
+      store2.setMeta("lastRescoreAt", String(started));
+      store2.setMeta("rescoresSinceFull", String(sinceFull + 1));
+      return inc;
+    }
+  }
+  const report = runFullRescore(store2);
+  store2.setMeta?.("lastRescoreAt", String(report.startedAt));
+  store2.setMeta?.("rescoresSinceFull", "0");
+  store2.setMeta?.("danglingRankShare", String(report.danglingRank));
+  const { startedAt: _drop, danglingRank: _drop2, ...rest } = report;
+  return rest;
+}
+function tryIncrementalRescore(store2, lastRescoreAt, started) {
+  const allowedTypes = new Set(pagerankEdgeTypes());
+  const liveN = store2.nodeCount();
+  const cap = Math.max(1e3, Math.floor(liveN * INCREMENTAL_REGION_MAX_FRACTION));
+  const region = new Set(store2.dirtyNodeIdsSince(lastRescoreAt));
+  for (const e of store2.edgeEndpointsTouchedSince(lastRescoreAt)) {
+    region.add(e.from);
+    region.add(e.to);
+  }
+  if (region.size > cap) return null;
+  let frontier = [...region];
+  for (let hop = 0; hop < INCREMENTAL_HOPS && frontier.length > 0; hop++) {
+    const next = [];
+    for (const e of store2.outEdgesForMany(frontier)) {
+      if (!allowedTypes.has(e.type)) continue;
+      if (!region.has(e.to)) {
+        region.add(e.to);
+        next.push(e.to);
+      }
+    }
+    if (region.size > cap) return null;
+    frontier = next;
+  }
+  const rank0 = store2.ranksForMany([...region]);
+  const regionIds = [...rank0.keys()];
+  if (regionIds.length === 0) {
+    return {
+      scoredNodes: 0,
+      iterations: 0,
+      converged: true,
+      landmarks: 0,
+      communities: 0,
+      motifsPromoted: 0,
+      techniques: 0,
+      antipatterns: 0,
+      pageRankWritten: 0,
+      landmarkFlips: 0,
+      mode: "incremental",
+      regionSize: 0,
+      durationMs: Date.now() - started
+    };
+  }
+  const inRegion = new Set(regionIds);
+  const out2 = /* @__PURE__ */ new Map();
+  const outSum = /* @__PURE__ */ new Map();
+  for (const e of store2.outEdgesForMany(regionIds)) {
+    if (!allowedTypes.has(e.type)) continue;
+    const w = EDGE_WEIGHT[e.type] ?? 1;
+    if (w <= 0) continue;
+    outSum.set(e.from, (outSum.get(e.from) ?? 0) + w);
+    if (!inRegion.has(e.to)) continue;
+    const l = out2.get(e.from);
+    if (l) l.push({ to: e.to, weight: w });
+    else out2.set(e.from, [{ to: e.to, weight: w }]);
+  }
+  const boundaryEdges = store2.inEdgesForMany(regionIds).filter((e) => allowedTypes.has(e.type) && !inRegion.has(e.from) && (EDGE_WEIGHT[e.type] ?? 1) > 0);
+  const boundarySources = [...new Set(boundaryEdges.map((e) => e.from))];
+  if (boundarySources.length > cap) return null;
+  const boundaryRanks = store2.ranksForMany(boundarySources);
+  const boundaryOutSum = /* @__PURE__ */ new Map();
+  for (const e of store2.outEdgesForMany(boundarySources)) {
+    if (!allowedTypes.has(e.type)) continue;
+    const w = EDGE_WEIGHT[e.type] ?? 1;
+    if (w > 0) boundaryOutSum.set(e.from, (boundaryOutSum.get(e.from) ?? 0) + w);
+  }
+  const boundaryInflow = /* @__PURE__ */ new Map();
+  for (const e of boundaryEdges) {
+    const r = boundaryRanks.get(e.from);
+    const os2 = boundaryOutSum.get(e.from);
+    if (r === void 0 || !os2) continue;
+    const w = EDGE_WEIGHT[e.type] ?? 1;
+    boundaryInflow.set(e.to, (boundaryInflow.get(e.to) ?? 0) + r * w / os2);
+  }
+  const globalDangling = Number(store2.getMeta("danglingRankShare") ?? 0);
+  let regionDangling = 0;
+  for (const id of regionIds) {
+    if ((outSum.get(id) ?? 0) <= 0) regionDangling += rank0.get(id) ?? 0;
+  }
+  const result = pagerankLocal({
+    regionIds,
+    rank0,
+    out: out2,
+    outSum,
+    boundaryInflow,
+    globalN: liveN,
+    externalDanglingRank: Math.max(0, globalDangling - regionDangling),
+    damping: 0.85,
+    tolerance: 1e-6,
+    maxIterations: 100
+  });
+  let pageRankWritten = 0;
+  store2.transaction(() => {
+    for (const [id, score2] of result.scores) {
+      if (Math.abs(score2 - (rank0.get(id) ?? 0)) < 1e-9) continue;
+      store2.setPageRank(id, score2);
+      pageRankWritten++;
+    }
+  });
+  const sweep = store2.landmarkSweepRows();
+  const candidates = /* @__PURE__ */ new Map();
+  for (const row of sweep) {
+    if (row.label === "Pattern" || row.label === "RootCause") {
+      candidates.set(row.id, result.scores.get(row.id) ?? row.pageRank);
+    }
+  }
+  const want = markLandmarks(candidates, 0.1);
+  for (const row of sweep) if (row.memoryTier === "persistent") want.add(row.id);
+  let landmarkFlips = 0;
+  store2.transaction(() => {
+    for (const row of sweep) {
+      if (row.extractionSource === "bko-inferred") continue;
+      const should = want.has(row.id);
+      if (row.isLandmark === should) continue;
+      store2.setLandmark(row.id, should);
+      landmarkFlips++;
+    }
+  });
+  return {
+    scoredNodes: regionIds.length,
+    iterations: result.iterations,
+    converged: result.converged,
+    landmarks: want.size,
+    communities: 0,
+    // deferred to the full backstop — see mode docs
+    motifsPromoted: 0,
+    techniques: 0,
+    antipatterns: 0,
+    pageRankWritten,
+    landmarkFlips,
+    mode: "incremental",
+    regionSize: regionIds.length,
+    durationMs: Date.now() - started
+  };
+}
+function runFullRescore(store2) {
   const started = Date.now();
   const allowedTypes = new Set(pagerankEdgeTypes());
   const nodeIds = [];
@@ -25959,10 +26890,12 @@ function runNightlyPipeline(store2) {
     maxIterations: 100
   });
   const scored = result.scores.size;
+  let pageRankWritten = 0;
   store2.transaction(() => {
     for (const [id, score2] of result.scores) {
       if (Math.abs(score2 - (meta3.get(id)?.pageRank ?? 0)) < 1e-9) continue;
       store2.setPageRank(id, score2);
+      pageRankWritten++;
     }
   });
   const landmarkCandidates = /* @__PURE__ */ new Map();
@@ -25977,11 +26910,13 @@ function runNightlyPipeline(store2) {
   for (const id of nodeIds) {
     if (meta3.get(id)?.memoryTier === "persistent") allLandmarks.add(id);
   }
+  let landmarkFlips = 0;
   store2.transaction(() => {
     for (const id of nodeIds) {
       const want = allLandmarks.has(id);
       if ((meta3.get(id)?.isLandmark ?? false) === want) continue;
       store2.setLandmark(id, want);
+      landmarkFlips++;
     }
   });
   const MOTIF_LABELS = /* @__PURE__ */ new Set(["Pattern", "Technique", "AntiPattern"]);
@@ -26016,8 +26951,6 @@ function runNightlyPipeline(store2) {
     for (const [id, c] of comm.community) store2.updateNode(id, { community: c });
   });
   const motifs = promoteMotifs(store2, started);
-  const designResolved = resolveDesignProblems(store2, started);
-  const cry = crystallize(store2, { ts: started });
   return {
     scoredNodes: scored,
     iterations: result.iterations,
@@ -26027,15 +26960,61 @@ function runNightlyPipeline(store2) {
     motifsPromoted: motifs.promoted,
     techniques: motifs.techniques,
     antipatterns: motifs.antipatterns,
-    skillsInduced: 0,
-    // skills are cloud-induced now (see above)
-    skillsRefreshed: 0,
+    pageRankWritten,
+    landmarkFlips,
+    mode: "full",
+    regionSize: 0,
+    startedAt: started,
+    danglingRank: result.danglingRank,
+    durationMs: Date.now() - started
+  };
+}
+function runSemanticMaintenance(store2) {
+  const started = Date.now();
+  reopenAutoClosedProblems(store2, started);
+  const revisits = clearAnsweredRevisits(store2, started);
+  const fixCandidates = clearSettledFixCandidates(store2, started);
+  const designResolved = markFixCandidates(store2, started);
+  const cry = crystallize(store2, { ts: started });
+  return {
     designResolved,
+    revisitsCleared: revisits.cleared,
+    revisitsStanding: revisits.standing,
+    fixCandidatesSettled: fixCandidates.answered + fixCandidates.ignored + fixCandidates.unsubstantiated,
+    fixCandidates,
     claimsEvaluated: cry.evaluated,
     claimsDerived: cry.derived.length,
     durationMs: Date.now() - started
   };
 }
+function runNightlyPipeline(store2) {
+  const started = Date.now();
+  const rescore = runGraphRescore(store2);
+  const semantic = runSemanticMaintenance(store2);
+  return {
+    scoredNodes: rescore.scoredNodes,
+    iterations: rescore.iterations,
+    converged: rescore.converged,
+    landmarks: rescore.landmarks,
+    communities: rescore.communities,
+    motifsPromoted: rescore.motifsPromoted,
+    techniques: rescore.techniques,
+    antipatterns: rescore.antipatterns,
+    skillsInduced: 0,
+    // skills are cloud-induced now (see above)
+    skillsRefreshed: 0,
+    pageRankWritten: rescore.pageRankWritten,
+    landmarkFlips: rescore.landmarkFlips,
+    mode: rescore.mode,
+    regionSize: rescore.regionSize,
+    designResolved: semantic.designResolved,
+    revisitsCleared: semantic.revisitsCleared,
+    fixCandidatesSettled: semantic.fixCandidatesSettled,
+    claimsEvaluated: semantic.claimsEvaluated,
+    claimsDerived: semantic.claimsDerived,
+    durationMs: Date.now() - started
+  };
+}
 function codeAnchorProjection(store2, semanticIds, opts = {}) {
   const anchorToNodes = /* @__PURE__ */ new Map();
   for (const id of semanticIds) {
@@ -26088,7 +27067,19 @@ function buildSnapshot(opts) {
     anchors: opts.store.outEdges(p.id, ["MANIFESTED_IN", "EVIDENCED_BY"])
   }));
   const recentConstraints = stillOpen.filter((p) => isConstraintProblem(p)).sort((a, b) => b.lastUpdatedAt - a.lastUpdatedAt).slice(0, 3);
-  const recentResolved = problems.filter((p) => p.attrs["resolvedAt"] != null && p.attrs["resolvedAs"] == null).sort((a, b) => Number(b.attrs["resolvedAt"] ?? 0) - Number(a.attrs["resolvedAt"] ?? 0)).slice(0, 4).map((p) => {
+  const regressions = problems.filter((p) => p.attrs["resolvedAt"] == null && p.attrs["mergedInto"] === void 0).flatMap(
+    (open) => opts.store.outEdges(open.id, ["REGRESSION_OF"]).flatMap((e) => {
+      const closed = opts.store.getNode(e.to);
+      if (!closed || closed.attrs["resolutionSuspect"] !== true || closed.attrs["resolvedAt"] == null) {
+        return [];
+      }
+      const solEdge = opts.store.outEdges(closed.id, ["SOLVED_BY"])[0];
+      const solution = solEdge ? opts.store.getNode(solEdge.to) ?? void 0 : void 0;
+      return [{ open, closed, ...solution ? { solution } : {} }];
+    })
+  ).sort((a, b) => Number(b.closed.attrs["recurredAt"] ?? 0) - Number(a.closed.attrs["recurredAt"] ?? 0)).slice(0, 2);
+  const regressionClosedIds = new Set(regressions.map((r) => r.closed.id));
+  const recentResolved = problems.filter((p) => p.attrs["resolvedAt"] != null && p.attrs["resolvedAs"] == null).filter((p) => !regressionClosedIds.has(p.id)).sort((a, b) => Number(b.attrs["resolvedAt"] ?? 0) - Number(a.attrs["resolvedAt"] ?? 0)).slice(0, 4).map((p) => {
     const solEdge = opts.store.outEdges(p.id, ["SOLVED_BY"])[0];
     const solution = solEdge ? opts.store.getNode(solEdge.to) ?? void 0 : void 0;
     return { node: p, ...solution ? { solution } : {} };
@@ -26158,7 +27149,9 @@ function buildSnapshot(opts) {
     recentProblems: recent,
     recentResolved,
     recentConstraints,
+    regressions,
     ...causalNudge ? { causalNudge } : {},
+    ...opts.selfCiteSkips && opts.selfCiteSkips > 0 ? { selfCiteSkips: opts.selfCiteSkips } : {},
     ...domainNudge ? { domainNudge } : {},
     motifs,
     reviewCount: opts.reviewCount,
@@ -26209,11 +27202,16 @@ function sliceForFile(store2, relPath) {
   }
   const fp = priorsForFile(store2, relPath);
   const priors = fp ? {
-    openProblems: fp.openProblems.slice(0, 3).map((p) => ({ id: p.id, description: p.description })),
+    openProblems: fp.openProblems.slice(0, 3).map((p) => ({
+      id: p.id,
+      description: p.description,
+      ...typeof p.attrs["fixCandidateFile"] === "string" ? { fixCandidateFile: p.attrs["fixCandidateFile"] } : {}
+    })),
     constraints: fp.constraints.slice(0, 2).map((c) => ({ id: c.id, description: c.description })),
+    resolvedProblems: fp.resolvedProblems.slice(0, 3).map((p) => ({ id: p.id, description: p.description })),
     related: fp.related.slice(0, 4).map((n) => ({ id: n.id, label: n.label, description: n.description })),
     solutionsByProblem: Object.fromEntries(
-      fp.openProblems.slice(0, 3).map((p) => [
+      [...fp.openProblems.slice(0, 3), ...fp.resolvedProblems.slice(0, 3)].map((p) => [
         p.id,
         (fp.solutionsByProblem.get(p.id) ?? []).slice(0, 4).map((s) => ({ id: s.id, description: s.description }))
       ])
@@ -26250,37 +27248,37 @@ init_src3();
 // ../../node_modules/.pnpm/env-paths@3.0.0/node_modules/env-paths/index.js
 import os from "node:os";
 import process3 from "node:process";
-var homedir = os.homedir();
+var homedir2 = os.homedir();
 var tmpdir = os.tmpdir();
 var { env } = process3;
 
 // src/paths.ts
-import { dirname as dirname2, join as join3 } from "node:path";
+import { dirname as dirname2, join as join4 } from "node:path";
 function workspaceDir(workspaceRoot) {
-  return join3(workspaceRoot, ".errata");
+  return join4(workspaceRoot, ".errata");
 }
 function workspacePaths(root) {
   const dir = workspaceDir(root);
   return {
     root,
     configDir: dir,
-    workspaceJson: join3(dir, "workspace.json"),
-    eventLog: join3(dir, "eventlog.sqlite"),
-    castalia: join3(dir, "castalia.db"),
-    reviewQueue: join3(dir, "review-queue.json"),
-    outbox: join3(dir, "outbox"),
-    daemonLock: join3(dir, "daemon.lock"),
-    identityAudit: join3(dir, "identity-audit.log"),
-    skillsDir: join3(dir, "skills"),
-    skillsManifest: join3(dir, "skills.json")
+    workspaceJson: join4(dir, "workspace.json"),
+    eventLog: join4(dir, "eventlog.sqlite"),
+    castalia: join4(dir, "castalia.db"),
+    reviewQueue: join4(dir, "review-queue.json"),
+    outbox: join4(dir, "outbox"),
+    daemonLock: join4(dir, "daemon.lock"),
+    identityAudit: join4(dir, "identity-audit.log"),
+    skillsDir: join4(dir, "skills"),
+    skillsManifest: join4(dir, "skills.json")
   };
 }
 
 // src/reconcile.ts
 init_src3();
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
-import { join as join4, relative as relative2, sep as sep2 } from "node:path";
+import { readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
+import { join as join5, relative as relative2, sep as sep2 } from "node:path";
 var IGNORED = /[\\/](?:\.git|node_modules|\.errata|dist|__pycache__)(?:[\\/]|$)/;
 var SOURCE_RE = /\.(ts|tsx|js|jsx|mjs|cjs|py)$/i;
 function gitSourceFiles(root) {
@@ -26297,7 +27295,7 @@ function gitSourceFiles(root) {
   const out2 = [];
   for (const rel of stdout.split("\0")) {
     if (!rel || !SOURCE_RE.test(rel)) continue;
-    const abs = join4(root, rel);
+    const abs = join5(root, rel);
     if (IGNORED.test(abs)) continue;
     out2.push(abs);
   }
@@ -26306,13 +27304,13 @@ function gitSourceFiles(root) {
 function* walkSource(dir) {
   let entries;
   try {
-    entries = readdirSync2(dir, { withFileTypes: true });
+    entries = readdirSync3(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
     const name2 = String(e.name);
-    const full = join4(dir, name2);
+    const full = join5(dir, name2);
     if (IGNORED.test(full)) continue;
     if (e.isDirectory()) yield* walkSource(full);
     else if (SOURCE_RE.test(name2)) yield full;
@@ -26321,12 +27319,18 @@ function* walkSource(dir) {
 function listSourceFiles(root) {
   return gitSourceFiles(root) ?? walkSource(root);
 }
-function findStaleFiles(store2, rootPath, workspaceId) {
+var SCAN_YIELD_EVERY = 100;
+var LIVENESS_CHUNK = 4e3;
+async function findStaleFiles(store2, rootPath, workspaceId) {
   const stale = [];
+  const pending = [];
+  const allTargets = [];
+  let scanned = 0;
   for (const abs of listSourceFiles(rootPath)) {
+    if (++scanned % SCAN_YIELD_EVERY === 0) await new Promise((r) => setImmediate(r));
     let mtimeMs;
     try {
-      mtimeMs = statSync2(abs).mtimeMs;
+      mtimeMs = statSync3(abs).mtimeMs;
     } catch {
       continue;
     }
@@ -26334,32 +27338,52 @@ function findStaleFiles(store2, rootPath, workspaceId) {
     const fnode = store2.getNode(fileNodeId(workspaceId, rel));
     if (!fnode) {
       stale.push(abs);
+    } else if ((fnode.validTo ?? null) !== null) {
+      stale.push(abs);
     } else if (fnode.lastUpdatedAt < mtimeMs) {
       stale.push(abs);
     } else {
       const edges = store2.outEdges(fnode.id, ["DEFINES", "CONTAINS"]);
       if (edges.length === 0) {
         stale.push(abs);
-      } else if (edges.some((e) => !isLive(store2.getNode(e.to)))) {
-        stale.push(abs);
+      } else {
+        const targets = edges.map((e) => e.to);
+        pending.push({ abs, targets });
+        allTargets.push(...targets);
       }
     }
   }
+  const live = /* @__PURE__ */ new Set();
+  for (let i2 = 0; i2 < allTargets.length; i2 += LIVENESS_CHUNK) {
+    for (const id of store2.liveNodeIds(allTargets.slice(i2, i2 + LIVENESS_CHUNK))) live.add(id);
+    if (i2 + LIVENESS_CHUNK < allTargets.length) await new Promise((r) => setImmediate(r));
+  }
+  for (const { abs, targets } of pending) {
+    if (targets.some((id) => !live.has(id))) stale.push(abs);
+  }
   return stale;
 }
-function isLive(n) {
-  return n != null && (n.validTo ?? null) === null;
-}
 async function reconcileStaleFiles(store2, rootPath, workspaceId) {
-  const stale = findStaleFiles(store2, rootPath, workspaceId);
+  const stale = await findStaleFiles(store2, rootPath, workspaceId);
   if (stale.length === 0) return 0;
   let total = 0;
+  let failedBatches = 0;
   const BATCH = 20;
   for (let i2 = 0; i2 < stale.length; i2 += BATCH) {
-    const r = await incrementalReindex(store2, rootPath, workspaceId, stale.slice(i2, i2 + BATCH));
-    total += r.filesReindexed;
+    try {
+      const r = await incrementalReindex(store2, rootPath, workspaceId, stale.slice(i2, i2 + BATCH));
+      total += r.filesReindexed;
+    } catch (err2) {
+      failedBatches++;
+      console.warn(
+        `[errata] reconcile: batch ${i2 / BATCH + 1} failed (${stale.slice(i2, i2 + BATCH).length} file(s) skipped): ${err2 instanceof Error ? err2.message : err2}`
+      );
+    }
     if (i2 + BATCH < stale.length) await new Promise((res) => setImmediate(res));
   }
+  if (failedBatches > 0) {
+    console.warn(`[errata] reconcile: ${failedBatches} batch(es) failed; ${total} file(s) reindexed`);
+  }
   return total;
 }
 
@@ -26412,6 +27436,7 @@ function runNightly() {
     const a = backfillLegacyAnchors(store, Date.now());
     anchorsDemoted = a.demotedEdges;
     resolutionsSuspect = a.suspects.length;
+    repairLegacyAnchorsFromStatement(store, Date.now());
   } catch {
   }
   const report = runNightlyPipeline(store);