@inerrata-corporation/errata 2.0.2-dev.70 → 2.0.2-dev.710

package/consolidate-worker.mjs

@@ -133,7 +133,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",
@@ -223,6 +230,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,
@@ -662,7 +673,7 @@ function lemma(token) {
   }
   return token;
 }
-function conceptTokens(text) {
+function tokenize(text, resolve) {
   const matches = text.normalize("NFC").toLowerCase().match(TOKEN_RE) ?? [];
   const out = /* @__PURE__ */ new Set();
   for (const raw of matches) {
@@ -672,11 +683,14 @@ function conceptTokens(text) {
       out.add(token);
       continue;
     }
-    const canonical = resolveCanonicalId(token);
+    const canonical = resolve(token);
     out.add(canonical ?? lemma(token));
   }
   return [...out].sort();
 }
+function conceptTokens(text) {
+  return tokenize(text, resolveCanonicalId);
+}
 function conceptBag(text) {
   return conceptTokens(text).join(" ");
 }
@@ -15194,13 +15208,21 @@ var init_edge_rules = __esm({
       // NOT ruled here — the type pre-exists with broader extractor senses, and a
       // new rule on an old type would reject legitimate live flows (reject-never-flip
       // cuts both ways: only rule types you introduce or senses that are documented).
-      CONCERNS: { from: ["Problem", "Solution", "RootCause", "Claim", "Pattern"], to: ["Tool"] },
+      // `Component` joined the target set with OM-agent-anchors: an agent-named
+      // component ("React Router") is the same knowledge→named-unit anchor shape as
+      // a Tool — the knowledge is ABOUT it, not dependent on it.
+      CONCERNS: { from: ["Problem", "Solution", "RootCause", "Claim", "Pattern"], to: ["Tool", "Component"] },
       OPERATES_ON: { from: ["Algorithm"], to: ["DataStructure"] },
       INVOLVES: { from: ["Problem", "Solution"], to: ["DataStructure"] },
       // ── 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) ──
@@ -15301,13 +15323,35 @@ 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
        *  knows which packages are private. The door does NOT trust a `public` claim
        *  blindly (it re-confirms on the spine); absent ⇒ unknown ⇒ fail-closed to
        *  org-private. Accepted-but-ignored until ORG_MEMBRANE_ENABLED flips. */
-      anchorVisibility: external_exports.enum(["public", "private"]).optional()
+      anchorVisibility: external_exports.enum(["public", "private"]).optional(),
+      /** The spine-resolvable anchor id backing a `public` tag (OM-anchor-tag): a
+       *  Package purl or `languageCanonicalId`. The door validates THIS on the
+       *  public spine (falling back to `canonicalId` when absent — context stubs
+       *  are self-anchored). Never trusted without spine confirmation. */
+      anchor: external_exports.string().min(1).max(300).optional()
     });
     RouteContextCountWireSchema = external_exports.object({
       confirmed: external_exports.number().int().min(0),
@@ -15396,7 +15440,7 @@ var init_canonicalize = __esm({
 
 // ../../packages/shared/src/nlp/triage-canon.ts
 function canonicalizeToken(t) {
-  const base = t.trim().toLowerCase().replace(/[@\s].*$/, "");
+  const base = t.trim().toLowerCase().replace(/(?!^)@.*$|\s.*$/, "");
   if (!base) return "";
   return resolveCanonicalId(base) ?? base;
 }
@@ -15478,6 +15522,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);
@@ -15490,6 +15579,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 {
     }
   }
@@ -15525,7 +15615,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");
@@ -15579,6 +15669,7 @@ var init_src2 = __esm({
     init_profile();
     init_daemon_wire();
     init_review();
+    init_anchorable();
     init_sqlite_adapter();
   }
 });
@@ -15744,9 +15835,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
@@ -15761,6 +15875,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,
@@ -16023,6 +16152,13 @@ var SqliteGraphStore = class {
       findByLabel: this.db.prepare(
         "SELECT * FROM nodes WHERE label = ? AND valid_to IS NULL"
       ),
+      // Scalar count twin of findByLabel — same live-row semantics, no row
+      // hydration. Exists because status surfaces (daemon `/` + `/health`) used
+      // findNodesByLabel(...).length, materializing every row's attrs JSON and
+      // embedding blob per request — seconds of synchronous loop-hold per poll.
+      countByLabel: this.db.prepare(
+        "SELECT COUNT(*) AS n FROM nodes WHERE label = ? AND valid_to IS NULL"
+      ),
       // ALL versions of a label — incl frozen/closed (valid_to set). Used by the
       // clean-reindex purge so a true wipe removes history too, not just live rows.
       findByLabelAll: this.db.prepare("SELECT * FROM nodes WHERE label = ?"),
@@ -16130,6 +16266,16 @@ var SqliteGraphStore = class {
           if (!cols.has(name)) 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);
     });
   }
@@ -16211,6 +16357,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;
     }
@@ -16235,22 +16382,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 {
+    }
+  }
+  /** 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 {
     }
-    const verdict = isValidEdge(fromLabel, edge.type, toLabel);
-    return verdict.ok ? null : verdict.reason ?? "edge rule violation";
+  }
+  edgeRuleViolation(edge) {
+    return localEdgeViolation(
+      this.getNode(edge.from)?.label,
+      edge.type,
+      this.getNode(edge.to)?.label
+    );
   }
   updateEdge(id, patch) {
     this.stmts.updateEdge.run({
@@ -16276,6 +16452,13 @@ var SqliteGraphStore = class {
     const rows = this.stmts.findByLabel.all(label);
     return rows.map(rowToNode);
   }
+  /** Live-row count for a label — `findNodesByLabel(label).length` without the
+   *  per-row hydration (attrs JSON + embedding blob). Status surfaces poll this
+   *  per project per request; the materializing form held the daemon's event
+   *  loop for seconds at scale. */
+  countNodesByLabel(label) {
+    return Number(this.stmts.countByLabel.get(label).n);
+  }
   findAllVersionsByLabel(label) {
     const rows = this.stmts.findByLabelAll.all(label);
     return rows.map(rowToNode);
@@ -16380,6 +16563,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 out = /* @__PURE__ */ new Map();
+    const CHUNK = 400;
+    for (let i = 0; i < ids.length; i += CHUNK) {
+      const chunk = ids.slice(i, i + 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) out.set(r.id, r.page_rank);
+    }
+    return out;
+  }
+  /** 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 out = [];
+    const CHUNK = 400;
+    for (let i = 0; i < ids.length; i += CHUNK) {
+      const chunk = ids.slice(i, i + 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) out.push({ from: r.from_id, to: r.to_id, type: r.type });
+    }
+    return out;
+  }
+  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 i = 0; i < relPaths.length; i += CHUNK) {
+      const slice = relPaths.slice(i, i + 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 i = 0; i < ids.length; i += CHUNK) {
+      const slice = ids.slice(i, i + 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. */
@@ -16400,6 +16740,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}`,
@@ -16458,6 +16802,7 @@ var CAUSAL_FAMILY = [
 
 // ../../packages/local-graph/src/justification.ts
 init_src();
+init_src2();
 
 // ../../packages/local-graph/src/credit.ts
 init_src2();
@@ -16474,11 +16819,28 @@ init_src();
 // ../../packages/local-graph/src/design-problem.ts
 init_src();
 init_src();
-init_src2();
 
 // ../../packages/local-graph/src/problem-package-link.ts
 init_src();
 
+// ../../packages/local-graph/src/design-problem.ts
+init_src2();
+
+// ../../packages/local-graph/src/problem-dedup.ts
+init_src();
+init_src();
+
+// ../../packages/local-graph/src/intent.ts
+init_src();
+
+// ../../packages/local-graph/src/anchor-backfill.ts
+init_src();
+init_src2();
+var STATEMENT_PATH_RE = new RegExp(
+  String.raw`(?:[\w.+-]+\/)+[\w.+-]+\.(?:${anchorableExtensionAlternation()})`,
+  "g"
+);
+
 // ../../packages/local-graph/src/percolate.ts
 init_src2();
 var PERCOLATING_LABELS = ["Claim", "Problem", "Solution"];
@@ -16749,219 +17111,13 @@ function detectCommunitiesLeiden(input, opts = {}) {
   return normalize(assignment);
 }
 
-// ../../packages/local-graph/src/abstraction.ts
-var DEFAULT_MIN_CLUSTER_SIZE = 3;
-var DEFAULT_MIN_DISTINCT_CONTEXTS = 2;
-function sharedScope(l2, memberIds) {
-  const shared = (field) => {
-    const vals = /* @__PURE__ */ new Set();
-    for (const id of memberIds) {
-      const s = l2.getNode(id)?.attrs["scope"] ?? {};
-      if (typeof s[field] === "string") vals.add(s[field]);
-    }
-    return vals.size === 1 ? [...vals][0] : void 0;
-  };
-  const lang = shared("lang");
-  const versionRange = shared("versionRange");
-  return { ...lang ? { lang } : {}, ...versionRange ? { versionRange } : {} };
-}
-function buildCandidate(id, ts, members, contexts, originMachine, scope) {
-  return {
-    id,
-    label: "Claim",
-    description: "",
-    // empty — the harness distills the prose in P3
-    extractionConfidence: 0.4,
-    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: {
-      abstractionLevel: ABSTRACTION_LEVEL.PRINCIPLE,
-      kind: "abstraction-candidate",
-      provisional: true,
-      pendingDistillation: true,
-      // membership is the unit of truth — the harness validates its fence against
-      // this set (P3 / C3) and may only phrase, never alter, it.
-      members,
-      memberContexts: contexts,
-      distinctContexts: contexts.length,
-      // standard Claim envelope so it crystallizes/syncs unchanged once distilled
-      truthKind: "contextual",
-      // Derived from members (P1): a single-language cluster becomes a lang-scoped
-      // principle; a cross-language one stays universal (`{}`).
-      scope,
-      groundedSupport: 0,
-      sources: [],
-      crystallized: "hypothesis",
-      confidence: 0.4,
-      ...originMachine ? { originMachine } : {}
-    }
-  };
-}
-function mergeGeneralizes(store, principleId, memberId, ts) {
-  store.mergeEdge({
-    id: `edge_${digest({ from: principleId, type: "GENERALIZES", to: memberId })}`.slice(0, 24),
-    from: principleId,
-    to: memberId,
-    type: "GENERALIZES",
-    confidence: 0.4,
-    extractionSource: "agent-observed",
-    createdAt: ts,
-    lastSeenAt: ts,
-    navSuccesses: 0,
-    navFailures: 0,
-    attrs: { provisional: true }
-  });
-}
-function induceAbstractions(l2, opts) {
-  const K = opts.minClusterSize ?? DEFAULT_MIN_CLUSTER_SIZE;
-  const minCtx = opts.minDistinctContexts ?? DEFAULT_MIN_DISTINCT_CONTEXTS;
-  const report = {
-    communities: 0,
-    candidatesMinted: 0,
-    candidatesExisting: 0,
-    skippedSmall: 0,
-    skippedSingleContext: 0,
-    generalizesEdges: 0
-  };
-  const ids = /* @__PURE__ */ new Set();
-  for (const label of PERCOLATING_LABELS) {
-    for (const n of l2.findNodesByLabel(label)) {
-      if (Number(n.attrs["abstractionLevel"] ?? ABSTRACTION_LEVEL.CONCRETE) >= ABSTRACTION_LEVEL.PRINCIPLE) {
-        continue;
-      }
-      if (n.attrs["resolvedAs"] === PROBLEM_RESOLUTION.FALSE_POSITIVE) continue;
-      ids.add(n.id);
-    }
-  }
-  if (ids.size === 0) return report;
-  const adj = /* @__PURE__ */ new Map();
-  const protect = [];
-  const add = (a, b, w) => {
-    const l = adj.get(a) ?? [];
-    l.push({ to: b, weight: w });
-    adj.set(a, l);
-  };
-  for (const id of ids) {
-    for (const e of l2.outEdges(id, [...PERCOLATING_EDGES])) {
-      if (!ids.has(e.to)) continue;
-      const conf = e.confidence > 0 ? e.confidence : 0.5;
-      const w = Math.max(EDGE_WEIGHT[e.type] ?? 1, 0.1) * conf;
-      add(id, e.to, w);
-      add(e.to, id, w);
-      if (isCausalProtected(e.type)) protect.push([id, e.to]);
-    }
-  }
-  const comm = detectCommunitiesLeiden({ nodeIds: [...ids], adj }, { protect });
-  report.communities = comm.count;
-  const members = /* @__PURE__ */ new Map();
-  for (const [id, c] of comm.community) {
-    const l = members.get(c) ?? [];
-    l.push(id);
-    members.set(c, l);
-  }
-  l2.transaction(() => {
-    for (const mem of members.values()) {
-      if (opts.touched && !mem.some((id) => opts.touched.has(id))) continue;
-      if (mem.length < K) {
-        report.skippedSmall++;
-        continue;
-      }
-      if (mem.some((id) => l2.inEdges(id, ["GENERALIZES"]).length > 0)) {
-        report.candidatesExisting++;
-        continue;
-      }
-      const contexts = /* @__PURE__ */ new Set();
-      for (const id of mem) {
-        const n = l2.getNode(id);
-        const obs = n?.attrs["observedInProjects"];
-        if (Array.isArray(obs)) {
-          for (const ws of obs) contexts.add(opts.contextOf(ws) ?? `project:${ws}`);
-        }
-      }
-      if (contexts.size < minCtx) {
-        report.skippedSingleContext++;
-        continue;
-      }
-      const sorted = [...mem].sort();
-      const principleId = `princ_${digest({ members: sorted })}`.slice(0, 56);
-      l2.mergeNode(
-        buildCandidate(principleId, opts.ts, sorted, [...contexts].sort(), opts.originMachine, sharedScope(l2, sorted))
-      );
-      for (const id of sorted) {
-        mergeGeneralizes(l2, principleId, id, opts.ts);
-        report.generalizesEdges++;
-      }
-      report.candidatesMinted++;
-    }
-  });
-  return report;
-}
-function revisitContradictedPrinciples(l2, ts) {
-  const report = { flagged: 0 };
-  l2.transaction(() => {
-    for (const n of l2.findNodesByLabel("Claim")) {
-      if (Number(n.attrs["abstractionLevel"] ?? ABSTRACTION_LEVEL.CONCRETE) < ABSTRACTION_LEVEL.PRINCIPLE) continue;
-      if (n.attrs["revisit"] === true) continue;
-      const members = Array.isArray(n.attrs["members"]) ? n.attrs["members"] : [];
-      const memberSet = new Set(members);
-      let reason = "";
-      for (const id of members) {
-        const m = l2.getNode(id);
-        if (!m) {
-          reason = `member ${id} was removed`;
-          break;
-        }
-        if (m.attrs["revisit"] === true) {
-          reason = `member "${m.description}" needs revisit`;
-          break;
-        }
-        const contradictors = [
-          ...l2.outEdges(id, ["CONTRADICTS"]).map((e) => e.to),
-          ...l2.inEdges(id, ["CONTRADICTS"]).map((e) => e.from)
-        ];
-        if (contradictors.some((other) => !memberSet.has(other))) {
-          reason = `member "${m.description}" is now contradicted by external evidence`;
-          break;
-        }
-      }
-      if (!reason) continue;
-      l2.updateNode(n.id, {
-        attrs: {
-          ...n.attrs,
-          revisit: true,
-          revisitReason: reason,
-          revisitSinceTs: ts,
-          provisional: true,
-          // re-queue for re-distillation (P3 re-name)
-          pendingDistillation: true
-        },
-        lastUpdatedAt: ts
-      });
-      report.flagged++;
-    }
-  });
-  return report;
-}
-
-// ../../packages/local-graph/src/community.ts
-init_src2();
-
 // ../../packages/local-graph/src/triage.ts
 init_src();
 init_src();
 init_src();
 init_src2();
-function semNode(id, label, description, ts, attrs) {
+function semNode(store, id, label, description, ts, attrs) {
+  const seq = SEMANTIC_NODE_LABELS.includes(label) ? store.nextIngestSeq() : void 0;
   return {
     id,
     label,
@@ -16979,6 +17135,7 @@ function semNode(id, label, description, ts, attrs) {
     isLandmark: false,
     community: null,
     stability: "unstable",
+    ...seq !== void 0 ? { createdAtSeq: seq, lastReinforcedAtSeq: seq } : {},
     attrs
   };
 }
@@ -17009,7 +17166,7 @@ function recordTriageObservation(l2, obs, ts) {
   const buckets = [...triageContextBuckets(canonicalizeContext(obs.context)), TRIAGE_GLOBAL_BUCKET];
   l2.transaction(() => {
     if (!l2.getNode(presentingId)) {
-      l2.mergeNode(semNode(presentingId, "Problem", statement, ts, { scope: {} }));
+      l2.mergeNode(semNode(l2, presentingId, "Problem", statement, ts, { scope: {} }));
     }
     const tri = l2.getNode(triageId);
     const seen = {
@@ -17023,7 +17180,7 @@ function recordTriageObservation(l2, obs, ts) {
       });
     } else {
       l2.mergeNode(
-        semNode(triageId, "Triage", `differential for: ${statement}`, ts, {
+        semNode(l2, triageId, "Triage", `differential for: ${statement}`, ts, {
           statement,
           perContextSeen: seen
         })
@@ -17035,7 +17192,7 @@ function recordTriageObservation(l2, obs, ts) {
     }
     if (!l2.getNode(obs.causeId)) {
       l2.mergeNode(
-        semNode(obs.causeId, obs.causeLabel ?? "RootCause", obs.causeDescription ?? "(cause)", ts, {
+        semNode(l2, obs.causeId, obs.causeLabel ?? "RootCause", obs.causeDescription ?? "(cause)", ts, {
           scope: {}
         })
       );
@@ -17208,9 +17365,212 @@ function revisitStaleRoutes(l2, ts, opts = {}) {
 }
 var DRIFT_VALUES = new Set(Object.values(DRIFT_KIND));
 
-// ../../packages/local-graph/src/problem-dedup.ts
-init_src();
-init_src();
+// ../../packages/local-graph/src/abstraction.ts
+var DEFAULT_MIN_CLUSTER_SIZE = 3;
+var DEFAULT_MIN_DISTINCT_CONTEXTS = 2;
+function sharedScope(l2, memberIds) {
+  const shared = (field) => {
+    const vals = /* @__PURE__ */ new Set();
+    for (const id of memberIds) {
+      const s = l2.getNode(id)?.attrs["scope"] ?? {};
+      if (typeof s[field] === "string") vals.add(s[field]);
+    }
+    return vals.size === 1 ? [...vals][0] : void 0;
+  };
+  const lang = shared("lang");
+  const versionRange = shared("versionRange");
+  return { ...lang ? { lang } : {}, ...versionRange ? { versionRange } : {} };
+}
+function buildCandidate(id, ts, members, contexts, originMachine, scope) {
+  return {
+    id,
+    label: "Claim",
+    description: "",
+    // empty — the harness distills the prose in P3
+    extractionConfidence: 0.4,
+    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: {
+      abstractionLevel: ABSTRACTION_LEVEL.PRINCIPLE,
+      kind: "abstraction-candidate",
+      provisional: true,
+      pendingDistillation: true,
+      // membership is the unit of truth — the harness validates its fence against
+      // this set (P3 / C3) and may only phrase, never alter, it.
+      members,
+      memberContexts: contexts,
+      distinctContexts: contexts.length,
+      // standard Claim envelope so it crystallizes/syncs unchanged once distilled
+      truthKind: "contextual",
+      // Derived from members (P1): a single-language cluster becomes a lang-scoped
+      // principle; a cross-language one stays universal (`{}`).
+      scope,
+      groundedSupport: 0,
+      sources: [],
+      crystallized: "hypothesis",
+      confidence: 0.4,
+      ...originMachine ? { originMachine } : {}
+    }
+  };
+}
+function mergeGeneralizes(store, principleId, memberId, ts) {
+  store.mergeEdge({
+    id: `edge_${digest({ from: principleId, type: "GENERALIZES", to: memberId })}`.slice(0, 24),
+    from: principleId,
+    to: memberId,
+    type: "GENERALIZES",
+    confidence: 0.4,
+    extractionSource: "agent-observed",
+    createdAt: ts,
+    lastSeenAt: ts,
+    navSuccesses: 0,
+    navFailures: 0,
+    attrs: { provisional: true }
+  });
+}
+function induceAbstractions(l2, opts) {
+  const K = opts.minClusterSize ?? DEFAULT_MIN_CLUSTER_SIZE;
+  const minCtx = opts.minDistinctContexts ?? DEFAULT_MIN_DISTINCT_CONTEXTS;
+  const report = {
+    communities: 0,
+    candidatesMinted: 0,
+    candidatesExisting: 0,
+    skippedSmall: 0,
+    skippedSingleContext: 0,
+    generalizesEdges: 0
+  };
+  const ids = /* @__PURE__ */ new Set();
+  for (const label of PERCOLATING_LABELS) {
+    for (const n of l2.findNodesByLabel(label)) {
+      if (Number(n.attrs["abstractionLevel"] ?? ABSTRACTION_LEVEL.CONCRETE) >= ABSTRACTION_LEVEL.PRINCIPLE) {
+        continue;
+      }
+      if (n.attrs["resolvedAs"] === PROBLEM_RESOLUTION.FALSE_POSITIVE) continue;
+      ids.add(n.id);
+    }
+  }
+  if (ids.size === 0) return report;
+  const adj = /* @__PURE__ */ new Map();
+  const protect = [];
+  const add = (a, b, w) => {
+    const l = adj.get(a) ?? [];
+    l.push({ to: b, weight: w });
+    adj.set(a, l);
+  };
+  for (const id of ids) {
+    for (const e of l2.outEdges(id, [...PERCOLATING_EDGES])) {
+      if (!ids.has(e.to)) continue;
+      const conf = e.confidence > 0 ? e.confidence : 0.5;
+      const w = Math.max(EDGE_WEIGHT[e.type] ?? 1, 0.1) * conf;
+      add(id, e.to, w);
+      add(e.to, id, w);
+      if (isCausalProtected(e.type)) protect.push([id, e.to]);
+    }
+  }
+  const comm = detectCommunitiesLeiden({ nodeIds: [...ids], adj }, { protect });
+  report.communities = comm.count;
+  const members = /* @__PURE__ */ new Map();
+  for (const [id, c] of comm.community) {
+    const l = members.get(c) ?? [];
+    l.push(id);
+    members.set(c, l);
+  }
+  l2.transaction(() => {
+    for (const mem of members.values()) {
+      if (opts.touched && !mem.some((id) => opts.touched.has(id))) continue;
+      if (mem.length < K) {
+        report.skippedSmall++;
+        continue;
+      }
+      if (mem.some((id) => l2.inEdges(id, ["GENERALIZES"]).length > 0)) {
+        report.candidatesExisting++;
+        continue;
+      }
+      const contexts = /* @__PURE__ */ new Set();
+      for (const id of mem) {
+        const n = l2.getNode(id);
+        const obs = n?.attrs["observedInProjects"];
+        if (Array.isArray(obs)) {
+          for (const ws of obs) contexts.add(opts.contextOf(ws) ?? `project:${ws}`);
+        }
+      }
+      if (contexts.size < minCtx) {
+        report.skippedSingleContext++;
+        continue;
+      }
+      const sorted = [...mem].sort();
+      const principleId = `princ_${digest({ members: sorted })}`.slice(0, 56);
+      l2.mergeNode(
+        buildCandidate(principleId, opts.ts, sorted, [...contexts].sort(), opts.originMachine, sharedScope(l2, sorted))
+      );
+      for (const id of sorted) {
+        mergeGeneralizes(l2, principleId, id, opts.ts);
+        report.generalizesEdges++;
+      }
+      report.candidatesMinted++;
+    }
+  });
+  return report;
+}
+function revisitContradictedPrinciples(l2, ts) {
+  const report = { flagged: 0 };
+  l2.transaction(() => {
+    for (const n of l2.findNodesByLabel("Claim")) {
+      if (Number(n.attrs["abstractionLevel"] ?? ABSTRACTION_LEVEL.CONCRETE) < ABSTRACTION_LEVEL.PRINCIPLE) continue;
+      if (n.attrs["revisit"] === true) continue;
+      const members = Array.isArray(n.attrs["members"]) ? n.attrs["members"] : [];
+      const memberSet = new Set(members);
+      let reason = "";
+      for (const id of members) {
+        const m = l2.getNode(id);
+        if (!m) {
+          reason = `member ${id} was removed`;
+          break;
+        }
+        if (m.attrs["revisit"] === true) {
+          reason = `member "${m.description}" needs revisit`;
+          break;
+        }
+        const contradictors = [
+          ...l2.outEdges(id, ["CONTRADICTS"]).map((e) => e.to),
+          ...l2.inEdges(id, ["CONTRADICTS"]).map((e) => e.from)
+        ];
+        if (contradictors.some((other) => !memberSet.has(other))) {
+          reason = `member "${m.description}" is now contradicted by external evidence`;
+          break;
+        }
+      }
+      if (!reason) continue;
+      l2.updateNode(n.id, {
+        attrs: {
+          ...n.attrs,
+          revisit: true,
+          revisitReason: reason,
+          revisitSinceTs: ts,
+          provisional: true,
+          // re-queue for re-distillation (P3 re-name)
+          pendingDistillation: true
+        },
+        lastUpdatedAt: ts
+      });
+      report.flagged++;
+    }
+  });
+  return report;
+}
+
+// ../../packages/local-graph/src/community.ts
+init_src2();
 
 // ../../packages/local-graph/src/tools.ts
 init_src();
@@ -17218,6 +17578,9 @@ init_src();
 // ../../packages/local-graph/src/principle-sync.ts
 init_src2();
 
+// ../../packages/local-graph/src/mechanism-liveness.ts
+var STALL_MIN_SPAN_MS = 60 * 60 * 1e3;
+
 // src/reconcile.ts
 init_src3();
 function isLive(n) {