@inerrata-corporation/errata 2.0.2-dev.85 → 2.0.2-dev.867

package/pass-worker.mjs

@@ -144,7 +144,14 @@ var init_castalia = __esm({
       "SOLVED_BY",
       "MITIGATES",
       "REPORTED_FAILURE",
-      "CONTRADICTS"
+      "CONTRADICTS",
+      // Motif twin-faces (KN-twin-faces): failure-face motif → remedy-face motif
+      // across layers (AntiPattern/Weakness ↔ Technique/Pattern). Same
+      // problem→fix direction as FIXED_BY/SOLVED_BY. Minted by the nightly LLM
+      // twin-face pass — these are the near-identical cross-layer pairs the
+      // polarity gate (finding 5) correctly refuses to FUSE; the link carries
+      // what fusion can't.
+      "REMEDIED_BY"
     ];
     CONCEPTUAL_EDGES = [
       "INSTANCE_OF",
@@ -259,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",
@@ -274,6 +285,10 @@ var init_castalia = __esm({
       CAUSED_BY: 3,
       FIXED_BY: 3,
       SOLVED_BY: 3,
+      // Twin-face link (failure motif → remedy motif, KN-twin-faces) — causal-grade
+      // but a notch below witnessed FIXED_BY/SOLVED_BY: the pairing is an LLM
+      // judgment over descriptions, not an agent-witnessed resolution.
+      REMEDIED_BY: 2.5,
       MANIFESTS_AS: 2,
       ESCALATES_TO: 1.5,
       AFFECTS: 1.2,
@@ -447,13 +462,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";
@@ -502,6 +522,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) {
@@ -563,7 +590,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) {
@@ -573,11 +600,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"() {
@@ -15058,7 +15088,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) ──
@@ -15159,6 +15194,23 @@ var init_wire = __esm({
       /** Canonical human-readable description (no raw paths — daemon scrubs; server rechecks). */
       description: external_exports.string().min(1).max(4e3),
       attrs: external_exports.record(external_exports.string(), external_exports.unknown()).default({}),
+      /** One-way origin key of the SESSION that minted this node (`ws_…`, a
+       *  truncated digest — never the raw session id). Stamped onto the created
+       *  node as `authoringSession`, which is the independence unit for the
+       *  evidence channels: the session that authored a claim may not corroborate
+       *  or refute it, while a DIFFERENT session on the same checkout may (alyssa,
+       *  2026-07-31 — the workspace key made every witness on a single-checkout
+       *  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
@@ -15331,6 +15383,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);
@@ -15343,6 +15440,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 {
     }
   }
@@ -15378,7 +15476,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");
@@ -15432,6 +15530,7 @@ var init_src2 = __esm({
     init_profile();
     init_daemon_wire();
     init_review();
+    init_anchorable();
     init_sqlite_adapter();
   }
 });
@@ -15454,7 +15553,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) {
@@ -15483,7 +15582,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);
@@ -15791,6 +15890,7 @@ 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 {
@@ -15803,6 +15903,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) {
@@ -15937,6 +16039,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])) {
@@ -16045,7 +16148,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,
@@ -16616,7 +16726,7 @@ async function scan(root, current, ignores, providers, out2) {
     }
   }
 }
-function gitListFiles(root, ignores, providers) {
+function gitListRelPaths(root, ignores) {
   let stdout;
   try {
     stdout = execFileSync(
@@ -16639,6 +16749,15 @@ function gitListFiles(root, ignores, providers) {
     if (segs.some((s) => ignores.has(s) || s.startsWith(".") && s.length > 1)) {
       continue;
     }
+    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 = join(root, rel);
     let size;
     try {
@@ -23978,6 +24097,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,
@@ -23994,6 +24114,7 @@ __export(src_exports, {
   findInnermostScope: () => findInnermostScope,
   folderNodeId: () => folderNodeId,
   fromHex: () => fromHex,
+  gitListRelPaths: () => gitListRelPaths,
   hammingDistance: () => hammingDistance,
   hasForkedDrift: () => hasForkedDrift,
   incrementalReindex: () => incrementalReindex,
@@ -24006,7 +24127,7 @@ __export(src_exports, {
   simhashFeatures: () => simhashFeatures,
   symbolNodeId: () => symbolNodeId,
   toHex: () => toHex,
-  tokenize: () => tokenize
+  tokenize: () => tokenize2
 });
 function defaultProviders() {
   if (providersCache) return providersCache;
@@ -24059,9 +24180,32 @@ 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"] }
 };
-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
@@ -24076,6 +24220,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,
@@ -24452,6 +24611,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);
     });
   }
@@ -24533,6 +24702,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;
     }
@@ -24557,22 +24727,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({
@@ -24709,6 +24908,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. */
@@ -24729,6 +25085,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}`,
@@ -24787,6 +25147,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 };
@@ -24809,13 +25170,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,
@@ -24948,7 +25368,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();
@@ -25134,42 +25553,102 @@ function backfillProblemContext(store2, ts) {
 }
 
 // ../../packages/local-graph/src/design-problem.ts
-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
-  };
+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 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 overlap(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let inter = 0;
+  for (const x of a) if (b.has(x)) inter++;
+  return inter / Math.min(a.size, b.size);
+}
+function mergeDuplicateProblems(store2, opts) {
+  const minOverlap = opts.minOverlap ?? 0.85;
+  const minTokens = opts.minTokens ?? 4;
+  const report = { clusters: 0, merged: 0 };
+  const open = store2.findNodesByLabel("Problem").filter((p) => p.attrs["resolvedAt"] == null && p.attrs["mergedInto"] === void 0);
+  const tokens = /* @__PURE__ */ new Map();
+  for (const p of open) tokens.set(p.id, new Set(retrievalTokens(p.description)));
+  const consumed = /* @__PURE__ */ new Set();
+  store2.transaction(() => {
+    for (let i2 = 0; i2 < open.length; i2++) {
+      const a = open[i2];
+      if (consumed.has(a.id)) continue;
+      const cluster = [a];
+      const ta = tokens.get(a.id);
+      for (let j = i2 + 1; j < open.length; j++) {
+        const b = open[j];
+        if (consumed.has(b.id)) continue;
+        const tb = tokens.get(b.id);
+        if (Math.min(ta.size, tb.size) < minTokens) continue;
+        if (isConstraintProblem(a) !== isConstraintProblem(b)) continue;
+        if (overlap(ta, tb) >= minOverlap) {
+          cluster.push(b);
+          consumed.add(b.id);
+        }
+      }
+      if (cluster.length < 2) continue;
+      report.clusters++;
+      cluster.sort((x, y) => corroborations(y) - corroborations(x) || x.createdAt - y.createdAt);
+      const survivor = cluster[0];
+      for (const dup of cluster.slice(1)) {
+        foldDuplicateProblem(store2, dup, survivor, opts.ts);
+        report.merged++;
+      }
+    }
+  });
+  return report;
+}
+function foldDuplicateProblem(store2, dup, survivor, ts) {
+  const surv = store2.getNode(survivor.id);
+  if (!surv) return;
+  const sources = new Set(surv.attrs["sources"] ?? []);
+  for (const s of dup.attrs["sources"] ?? []) sources.add(s);
+  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/design-problem.ts
+function isConstraintProblem(node) {
+  return node.attrs["kind"] === "constraint";
 }
 var CITABLE_PRIOR_LABELS = /* @__PURE__ */ new Set([
   "Solution",
@@ -25178,6 +25657,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;
@@ -25189,35 +25671,53 @@ 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);
-        openProblems.push(n);
-      }
-    } else if (CITABLE_PRIOR_LABELS.has(n.label)) {
+      if (seenProblem.has(n.id)) continue;
+      seenProblem.add(n.id);
+      if (!n.attrs["resolvedAt"]) {
+        (isConstraintProblem(n) ? constraints : openProblems).push(n);
+      } else if (n.attrs["resolvedAs"] == null && n.attrs["mergedInto"] === void 0 && e.attrs?.["anchorProvenance"] !== "legacy") {
+        resolvedProblems.push(n);
+      }
+    } else if (CITABLE_PRIOR_LABELS.has(n.label) && !isAutoMinted(n)) {
       related.set(n.id, n);
     }
   }
   const solutionsByProblem = /* @__PURE__ */ new Map();
-  for (const p of openProblems) {
+  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 && related.size === 0) return null;
-  openProblems.sort((a, b) => (b.lastUpdatedAt ?? 0) - (a.lastUpdatedAt ?? 0));
-  return { file: file2, openProblems, related: [...related.values()], solutionsByProblem };
+  if (openProblems.length === 0 && constraints.length === 0 && resolvedProblems.length === 0 && related.size === 0)
+    return null;
+  const recentFirst = (a, b) => (b.lastUpdatedAt ?? 0) - (a.lastUpdatedAt ?? 0);
+  openProblems.sort(recentFirst);
+  constraints.sort(recentFirst);
+  resolvedProblems.sort(
+    (a, b) => Number(b.attrs["resolvedAt"] ?? 0) - Number(a.attrs["resolvedAt"] ?? 0)
+  );
+  return {
+    file: file2,
+    openProblems,
+    constraints,
+    resolvedProblems,
+    related: [...related.values()],
+    solutionsByProblem
+  };
 }
 function recordAnchorHint(store2, problemId, relPath, provenance, ts) {
   const p = store2.getNode(problemId);
@@ -25228,18 +25728,49 @@ function recordAnchorHint(store2, problemId, relPath, provenance, ts) {
   });
   return true;
 }
-function resolveDesignProblems(store2, t) {
+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 markFixCandidates(store2, t) {
   let resolved = 0;
   for (const p of store2.findNodesByLabel("Problem")) {
     if (!p.id.startsWith("dprob_")) continue;
     if (p.attrs["resolvedAt"]) continue;
+    if (isConstraintProblem(p)) continue;
     let symName = "";
     let symRelPath;
     let edited = false;
+    const since = Math.max(p.createdAt, Number(p.attrs["fixCandidateClearedAt"] ?? 0));
     for (const e of store2.outEdges(p.id, ["ANCHORED_AT"])) {
       if (e.attrs?.["mention"] === true) continue;
+      if (e.attrs?.["anchorProvenance"] === "legacy") continue;
       const sym = store2.getNode(e.to);
-      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;
@@ -25247,36 +25778,172 @@ 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", `addressed by an edit to ${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;
+}
+
+// ../../packages/local-graph/src/intent.ts
+init_src();
 
 // ../../packages/local-graph/src/anchor-backfill.ts
-var AUTO_MINT_PREFIX = "addressed by an edit to ";
+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,
@@ -25316,7 +25983,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 },
@@ -25350,7 +26021,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);
@@ -25422,8 +26093,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()];
@@ -25433,7 +26108,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++) {
@@ -25671,8 +26346,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();
@@ -25681,95 +26434,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 (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();
@@ -25786,6 +26452,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();
@@ -25905,7 +26574,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 = [];
@@ -25931,10 +26757,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();
@@ -25949,11 +26777,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"]);
@@ -25988,8 +26818,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,
@@ -25999,15 +26827,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) {
@@ -26052,12 +26926,14 @@ var AGENTS_POINTER_BODY = [
 init_src2();
 function buildSnapshot(opts) {
   const problems = opts.store.findNodesByLabel("Problem").filter((p) => p.attrs["mergedInto"] === void 0);
-  const allProblems = problems.filter((p) => p.attrs["resolvedAt"] == null);
+  const stillOpen = problems.filter((p) => p.attrs["resolvedAt"] == null);
+  const allProblems = stillOpen.filter((p) => !isConstraintProblem(p));
   allProblems.sort((a, b) => b.lastUpdatedAt - a.lastUpdatedAt);
   const recent = allProblems.slice(0, 8).map((p) => ({
     node: p,
     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 solEdge = opts.store.outEdges(p.id, ["SOLVED_BY"])[0];
     const solution = solEdge ? opts.store.getNode(solEdge.to) ?? void 0 : void 0;
@@ -26085,10 +26961,13 @@ function buildSnapshot(opts) {
     episodeId,
     problems: problems2
   }));
-  const needsRevisit = listNeedsRevisit(
-    opts.store,
-    (opts.now ?? /* @__PURE__ */ new Date()).getTime()
-  ).slice(0, 10);
+  const revisitSeen = /* @__PURE__ */ new Set();
+  const needsRevisit = listNeedsRevisit(opts.store, (opts.now ?? /* @__PURE__ */ new Date()).getTime()).filter((r) => {
+    const key = `${r.label}:${r.description.trim().toLowerCase()}`;
+    if (revisitSeen.has(key)) return false;
+    revisitSeen.add(key);
+    return true;
+  }).slice(0, 5);
   const norm = (x) => x.toLowerCase().replace(/[^a-z0-9]+/g, "");
   const pkgBase = (x) => {
     const at = x.lastIndexOf("@");
@@ -26124,7 +27003,9 @@ function buildSnapshot(opts) {
     profileContext,
     recentProblems: recent,
     recentResolved,
+    recentConstraints,
     ...causalNudge ? { causalNudge } : {},
+    ...opts.selfCiteSkips && opts.selfCiteSkips > 0 ? { selfCiteSkips: opts.selfCiteSkips } : {},
     ...domainNudge ? { domainNudge } : {},
     motifs,
     reviewCount: opts.reviewCount,
@@ -26175,10 +27056,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 }))
       ])
@@ -26286,9 +27173,15 @@ 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;
@@ -26299,32 +27192,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;
 }
 
@@ -26377,6 +27290,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);