@inerrata-corporation/errata 2.0.2-dev.517 → 2.0.2-dev.532

package/errata.mjs

@@ -17314,6 +17314,10 @@ CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.re
         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}`,
@@ -17699,14 +17703,17 @@ function markRevisit(store, node2, reason, ts, answeredWhen) {
       revisit: true,
       revisitReason: reason,
       revisitSinceTs: ts,
-      ...answeredWhen ? { revisitAnsweredWhen: answeredWhen } : {}
+      revisitAnsweredWhen: answeredWhen
     },
     lastUpdatedAt: ts
   });
 }
+function isRevisitCondition(v) {
+  return typeof v === "string" && Object.prototype.hasOwnProperty.call(KNOWN_CONDITIONS, v);
+}
 function conditionOf(node2) {
   const explicit = node2.attrs["revisitAnsweredWhen"];
-  if (explicit === "parentProblemOpen") return explicit;
+  if (isRevisitCondition(explicit)) return explicit;
   if (String(node2.attrs["revisitReason"] ?? "").startsWith(LEGACY_AUTO_CLOSE_ASK)) {
     return "parentProblemOpen";
   }
@@ -17714,23 +17721,32 @@ function conditionOf(node2) {
 }
 function clearAnsweredRevisits(store, ts) {
   const report = { cleared: 0, standing: 0 };
-  for (const node2 of store.findNodesByLabel("Solution")) {
-    if (node2.attrs["revisit"] !== true) continue;
-    if (conditionOf(node2) !== "parentProblemOpen") {
-      report.standing++;
-      continue;
-    }
-    const parents = store.inEdges(node2.id, ["SOLVED_BY"]).map((e) => store.getNode(e.from)).filter((n) => n !== null);
-    const answered = parents.every((p) => p.attrs["resolvedAt"] == null);
-    if (!answered) {
-      report.standing++;
-      continue;
+  for (const label of SEMANTIC_NODE_LABELS) {
+    for (const node2 of store.findNodesByLabel(label)) {
+      if (node2.attrs["revisit"] !== true) continue;
+      const condition = conditionOf(node2);
+      if (condition === void 0 || !isRevisitAnswered(store, node2, condition)) {
+        report.standing++;
+        continue;
+      }
+      clearRevisit(store, node2.id, ts);
+      report.cleared++;
     }
-    clearRevisit(store, node2.id, ts);
-    report.cleared++;
   }
   return report;
 }
+function isRevisitAnswered(store, node2, condition) {
+  switch (condition) {
+    case "parentProblemOpen": {
+      const parents = store.inEdges(node2.id, ["SOLVED_BY"]).map((e) => store.getNode(e.from)).filter((n) => n !== null && n.validTo == null);
+      return parents.every((p) => p.attrs["resolvedAt"] == null);
+    }
+    case "dependentStale": {
+      const since = Number(node2.attrs["revisitSinceTs"] ?? 0);
+      return since > 0 && node2.lastUpdatedAt > since;
+    }
+  }
+}
 function clearRevisit(store, nodeId, ts) {
   const n = store.getNode(nodeId);
   if (!n) return;
@@ -17756,7 +17772,7 @@ function cascade(store, seeds, visited, flagged, ts) {
     visited.add(id);
     const node2 = store.getNode(id);
     if (!node2) continue;
-    markRevisit(store, node2, reason, ts);
+    markRevisit(store, node2, reason, ts, "dependentStale");
     flagged.push({ id, label: node2.label, description: node2.description, reason });
     for (const e of store.inEdges(id, ["DEPENDS_ON"])) {
       queue.push({
@@ -17803,12 +17819,17 @@ function propagateFactChange(store, opts) {
   cascade(store, seeds, visited, flagged, opts.ts);
   return flagged;
 }
-var LEGACY_AUTO_CLOSE_ASK;
+var LEGACY_AUTO_CLOSE_ASK, KNOWN_CONDITIONS;
 var init_justification = __esm({
   "../../packages/local-graph/src/justification.ts"() {
     "use strict";
     init_src();
+    init_src2();
     LEGACY_AUTO_CLOSE_ASK = "auto-closed off a pre-provenance anchor";
+    KNOWN_CONDITIONS = {
+      parentProblemOpen: true,
+      dependentStale: true
+    };
   }
 });
 
@@ -18788,7 +18809,8 @@ function isPlaceholderStatement(statement) {
   if (bracketed.length > 0 && bracketedLen >= s.length * 0.6) return true;
   return false;
 }
-function buildNode(id, label, description, ts, attrs) {
+function buildNode(store, id, label, description, ts, attrs) {
+  const seq = SEMANTIC_NODE_LABELS.includes(label) ? store.nextIngestSeq() : void 0;
   return {
     id,
     label,
@@ -18807,9 +18829,14 @@ function buildNode(id, label, description, ts, attrs) {
     isLandmark: false,
     community: null,
     stability: "unstable",
+    ...seq !== void 0 ? { createdAtSeq: seq, lastReinforcedAtSeq: seq } : {},
     attrs
   };
 }
+function reinforcedSeqAttrs(store, label) {
+  if (!SEMANTIC_NODE_LABELS.includes(label)) return {};
+  return { lastReinforcedAtSeq: store.nextIngestSeq() };
+}
 function mergeEdge(store, from, to, type, ts) {
   store.mergeEdge({
     id: `edge_${digest({ from, type, to })}`.slice(0, 24),
@@ -18889,13 +18916,19 @@ function ingestDesignProblem(store, flag, opts) {
         },
         cumulativeHits: (existing.cumulativeHits ?? 0) + 1,
         ...promoted ? { extractionConfidence: 0.65 } : {},
+        // A corroborating re-flag is a REINFORCE: advance the sequence and move
+        // this node's marker with it, which resets its Δseq and makes it read
+        // fresh again. Without this the mint path would advance the ruler while
+        // re-observation never moved along it, so a heavily-reinforced node would
+        // decay exactly as fast as one nobody has mentioned since.
+        ...reinforcedSeqAttrs(store, existing.label),
         lastUpdatedAt: opts.ts
       });
     }
   } else {
     created = true;
     store.mergeNode(
-      buildNode(problemId, "Problem", statement, opts.ts, {
+      buildNode(store, problemId, "Problem", statement, opts.ts, {
         source: "convo",
         provisional: true,
         kind: flag.kind ?? "problem",
@@ -18910,7 +18943,7 @@ function ingestDesignProblem(store, flag, opts) {
   if (flag.cause?.trim()) {
     rootCauseId = `dcause_${digest({ problemId, cause: flag.cause })}`.slice(0, 56);
     store.mergeNode(
-      buildNode(rootCauseId, "RootCause", flag.cause.trim(), opts.ts, {
+      buildNode(store, rootCauseId, "RootCause", flag.cause.trim(), opts.ts, {
         source: "convo",
         provisional: true
       })
@@ -18921,7 +18954,7 @@ function ingestDesignProblem(store, flag, opts) {
   if (flag.fix?.trim()) {
     solutionId = `dfix_${digest({ problemId, fix: flag.fix })}`.slice(0, 56);
     store.mergeNode(
-      buildNode(solutionId, "Solution", flag.fix.trim(), opts.ts, {
+      buildNode(store, solutionId, "Solution", flag.fix.trim(), opts.ts, {
         source: "convo",
         provisional: true,
         rationale: flag.fix.trim()
@@ -18961,6 +18994,8 @@ function mintPatternNode(store, name2, ts) {
         observedCount: (Number(node2.attrs["observedCount"]) || 1) + 1,
         ...aliases.length > 0 ? { aliasTexts: aliases } : {}
       },
+      // Re-observing a Pattern is a REINFORCE on the same ruler as minting one.
+      ...reinforcedSeqAttrs(store, node2.label),
       lastUpdatedAt: ts
     });
     return node2.id;
@@ -18981,7 +19016,7 @@ function mintPatternNode(store, name2, ts) {
   }
   if (best && bestCos >= PATTERN_DEDUP_COSINE) return reinforce(best, display);
   store.mergeNode({
-    ...buildNode(id, "Pattern", display, ts, { source: "convo", provisional: true, observedCount: 1 }),
+    ...buildNode(store, id, "Pattern", display, ts, { source: "convo", provisional: true, observedCount: 1 }),
     // Embedded inline (sync hash) so the node participates in the gate
     // immediately — buildNode's empty embedding would leave every new pattern
     // invisible to dedup until the nightly embed pass.
@@ -18997,7 +19032,7 @@ function mintDomainNode(store, name2, ts) {
   const id = `dom_${digest({ domain: display.toLowerCase() })}`.slice(0, 56);
   if (!store.getNode(id)) {
     store.mergeNode(
-      buildNode(id, "Domain", display, ts, {
+      buildNode(store, id, "Domain", display, ts, {
         source: "convo",
         provisional: true,
         canonicalId: genericCanonicalId("dom", { type: "Domain", description: display })
@@ -19028,7 +19063,7 @@ function mintCitedPackageNode(store, ref, ts) {
   const purl = `pkg:${eco}/${purlName}`;
   if (!store.getNode(purl)) {
     store.mergeNode(
-      buildNode(purl, "Package", name2, ts, {
+      buildNode(store, purl, "Package", name2, ts, {
         purl,
         name: name2,
         ecosystem: eco,
@@ -19048,7 +19083,7 @@ function mintComponentNode(store, name2, ts) {
   const existing = store.getNode(slug2);
   if (!existing) {
     store.mergeNode(
-      buildNode(slug2, "Component", display, ts, {
+      buildNode(store, slug2, "Component", display, ts, {
         name: display,
         source: "convo",
         provisional: true,
@@ -19255,7 +19290,7 @@ function closeDesignProblem(store, problemId, fixNote, t) {
   if (fixNote?.trim() && store.outEdges(problemId, ["SOLVED_BY"]).length === 0) {
     const solId = `dfix_${digest({ problemId, fix: fixNote })}`.slice(0, 56);
     store.mergeNode(
-      buildNode(solId, "Solution", fixNote.trim(), t, { source: "convo", provisional: false })
+      buildNode(store, solId, "Solution", fixNote.trim(), t, { source: "convo", provisional: false })
     );
     mergeEdge(store, problemId, solId, "SOLVED_BY", t);
   }
@@ -20613,7 +20648,8 @@ var init_src4 = __esm({
 });
 
 // ../../packages/local-graph/src/triage.ts
-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,
@@ -20631,6 +20667,7 @@ function semNode(id, label, description, ts, attrs) {
     isLandmark: false,
     community: null,
     stability: "unstable",
+    ...seq !== void 0 ? { createdAtSeq: seq, lastReinforcedAtSeq: seq } : {},
     attrs
   };
 }
@@ -20661,7 +20698,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 = {
@@ -20675,7 +20712,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
         })
@@ -20687,7 +20724,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: {}
         })
       );
@@ -20751,7 +20788,7 @@ function recordCauseChainLink(l2, link, ts, attrs = {}) {
       [link.fromId, link.fromDescription],
       [link.toId, link.toDescription]
     ]) {
-      if (!l2.getNode(id)) l2.mergeNode(semNode(id, "RootCause", description, ts, { ...attrs }));
+      if (!l2.getNode(id)) l2.mergeNode(semNode(l2, id, "RootCause", description, ts, { ...attrs }));
     }
     const edgeId2 = `edge_cb_${link.fromId}_${link.toId}`;
     if (!l2.getEdge(edgeId2)) {
@@ -20774,7 +20811,7 @@ function mintWorkspaceCausalFact(ws, fact, ts) {
   ws.transaction(() => {
     if (!ws.getNode(fact.causeId)) {
       ws.mergeNode(
-        semNode(fact.causeId, "RootCause", description, ts, {
+        semNode(ws, fact.causeId, "RootCause", description, ts, {
           scope: {},
           ...fact.sessionId ? { sources: [fact.sessionId] } : {}
         })
@@ -21116,7 +21153,7 @@ function harvestTriageFences(l2, text, opts) {
       const fix = f.fix.trim();
       const fixId = `dfix_${digest({ cause: causeId, fix })}`.slice(0, 56);
       if (!l2.getNode(fixId)) {
-        l2.mergeNode(semNode(fixId, "Solution", fix, opts.ts, { scope: {} }));
+        l2.mergeNode(semNode(l2, fixId, "Solution", fix, opts.ts, { scope: {} }));
       }
       const solEdgeId = `edge_sol_${causeId}_${fixId}`;
       if (!l2.getEdge(solEdgeId)) {
@@ -21799,6 +21836,169 @@ var init_principle_sync = __esm({
   }
 });
 
+// ../../packages/local-graph/src/mechanism-liveness.ts
+function evaluateFed(store, d) {
+  const column = COLUMN_INPUTS[d.fed.attr];
+  const has = (n) => column ? column(n) : n.attrs[d.fed.attr] !== void 0;
+  const nodes = d.fed.labels.flatMap((label) => store.findNodesByLabel(label));
+  let window2 = nodes;
+  if (d.fed.recent !== void 0) {
+    window2 = [...nodes].sort((a, b) => b.createdAt - a.createdAt).slice(0, d.fed.recent);
+  }
+  if (d.fed.sinceFirstStamp) {
+    let anchor = Infinity;
+    for (const n of window2) if (has(n) && n.createdAt < anchor) anchor = n.createdAt;
+    window2 = anchor === Infinity ? [] : window2.filter((n) => n.createdAt >= anchor);
+  }
+  let count = 0;
+  for (const n of window2) if (has(n)) count++;
+  return { count, total: window2.length, fraction: window2.length === 0 ? 0 : count / window2.length };
+}
+function evaluateMechanisms(store, invocations = /* @__PURE__ */ new Map(), mechanisms = MECHANISMS) {
+  return mechanisms.map((d) => {
+    const fed = evaluateFed(store, d);
+    const inv = invocations.get(d.pass);
+    const effectCount = inv?.totals[d.effectCounter] ?? 0;
+    const backlog = d.backlogCounter ? inv?.lastTotals?.[d.backlogCounter] : void 0;
+    const backlogWas = d.backlogCounter ? inv?.firstTotals?.[d.backlogCounter] : void 0;
+    const span = inv?.firstTs === void 0 ? 0 : inv.lastTs - inv.firstTs;
+    const stalled = backlog !== void 0 && backlog > 0 && effectCount === 0 && (inv?.runs ?? 0) >= STALL_MIN_RUNS && span >= STALL_MIN_SPAN_MS && (backlogWas === void 0 || backlog >= backlogWas);
+    let verdict;
+    if (!inv || inv.runs === 0) verdict = "never-invoked";
+    else if (fed.fraction < d.fed.minFraction) verdict = "starved";
+    else if (stalled) verdict = "stalled";
+    else if (effectCount === 0) verdict = "no-effect";
+    else verdict = "ok";
+    return {
+      id: d.id,
+      what: d.what,
+      pass: d.pass,
+      fedCount: fed.count,
+      fedTotal: fed.total,
+      fedFraction: fed.fraction,
+      minFraction: d.fed.minFraction,
+      ...inv ? { lastInvokedMs: inv.lastTs } : {},
+      runs: inv?.runs ?? 0,
+      effectCount,
+      ...backlog !== void 0 ? { backlog } : {},
+      ...backlogWas !== void 0 ? { backlogWas } : {},
+      ...inv?.firstTs !== void 0 ? { spanMs: span } : {},
+      verdict,
+      ...d.note ? { note: d.note } : {}
+    };
+  });
+}
+function formatMechanismStatus(rows, nowMs) {
+  return rows.map((r) => {
+    const pct = (r.fedFraction * 100).toFixed(r.fedFraction < 0.01 ? 2 : 1);
+    const age = r.lastInvokedMs === void 0 ? "never" : `${Math.max(0, Math.round((nowMs - r.lastInvokedMs) / 6e4))}m ago`;
+    const mark = r.verdict === "ok" ? "ok  " : r.verdict === "no-effect" ? "IDLE" : r.verdict === "stalled" ? "STUCK" : "DEAD";
+    const hours = r.spanMs === void 0 ? 0 : Math.floor(r.spanMs / 36e5);
+    const over = hours >= 24 ? `${Math.floor(hours / 24)}d` : `${hours}h`;
+    const trend = r.verdict === "stalled" && r.backlog !== void 0 ? `  \u2014 ${r.backlog} waiting${r.backlogWas !== void 0 ? ` (was ${r.backlogWas})` : ""}, none cleared in ${over}` : "";
+    return `${mark.padEnd(6)}${r.id.padEnd(20)} invoked ${age.padEnd(9)} ` + `fed ${pct}% (${r.fedCount}/${r.fedTotal})`.padEnd(28) + `effect ${r.effectCount}` + trend + (r.verdict !== "ok" && r.note ? `  \u2014 ${r.note}` : "");
+  });
+}
+function hasStarvedMechanism(rows) {
+  return rows.some(
+    (r) => r.verdict === "never-invoked" || r.verdict === "starved" || r.verdict === "stalled"
+  );
+}
+var STALL_MIN_RUNS, STALL_MIN_SPAN_MS, MECHANISMS, COLUMN_INPUTS;
+var init_mechanism_liveness = __esm({
+  "../../packages/local-graph/src/mechanism-liveness.ts"() {
+    "use strict";
+    STALL_MIN_RUNS = 3;
+    STALL_MIN_SPAN_MS = 60 * 60 * 1e3;
+    MECHANISMS = [
+      {
+        id: "fix-candidate-ask",
+        what: "asks an agent whether an edit to a problem's anchor fixed it",
+        pass: "semantic-maintenance",
+        // markFixCandidates fails CLOSED on a File anchor with no contentChangedAt —
+        // correct (the alternative manufactured 92 asks out of no-op reindexes) and
+        // exactly why coverage must be watched rather than assumed. Measured over
+        // the recently-TOUCHED files, because the stamp is forward-only: whole-corpus
+        // coverage on this store is ~0.5% and says nothing about whether the
+        // producer works.
+        fed: { labels: ["File"], attr: "contentChangedAt", minFraction: 0.02, recent: 200 },
+        effectCounter: "fixCandidatesSettled",
+        // Standing asks ARE the queue: 94 of them sat forever while the sweep
+        // reported zero every run, and nothing could tell that from a clean backlog.
+        backlogCounter: "fixCandidatesStanding",
+        note: "stamped forward-only; measured over the 200 newest File nodes"
+      },
+      {
+        id: "revisit-sweep",
+        what: "retires a revisit ask once its recorded condition is met",
+        pass: "semantic-maintenance",
+        fed: {
+          labels: ["Solution", "Problem", "RootCause", "Pattern"],
+          attr: "revisitAnsweredWhen",
+          // Only FLAGGED nodes carry it, and flags are rare by design, so the bar is
+          // "the field is written at all" — it was written zero times before this.
+          minFraction: 0
+        },
+        effectCounter: "revisitsCleared",
+        backlogCounter: "revisitsStanding"
+      },
+      {
+        id: "ingest-sequence",
+        what: "orders knowledge arrivals so decay is driven by superseding info, not the clock",
+        // CAPTURE, not semantic-maintenance. The sequence advances where knowledge
+        // ENTERS the graph, and the maintenance pass never mints — so pointing this
+        // at maintenance named a counter that is structurally always zero and the
+        // mechanism read IDLE forever while stamping every new node. A descriptor
+        // that cannot report an effect is the same defect it exists to detect.
+        pass: "capture",
+        fed: {
+          labels: ["Problem", "Solution", "RootCause", "Pattern"],
+          attr: "__createdAtSeq",
+          // UNIVERSAL stamp: every semantic node minted after the producer went live
+          // carries a sequence position, so the honest metric is "of the nodes born
+          // since the first stamp, how many are stamped" — an invariant that should
+          // read ~1.0 always. The 173k pre-fix nodes are deliberately never
+          // backfilled (inventing a sequence position would feed the decay math
+          // fabricated evidence it would read as real), and a recent-N window would
+          // have to turn over 50 nodes before it could go green: it read 6% while
+          // the producer was verifiably stamping every new node.
+          minFraction: 0.9,
+          recent: 200,
+          sinceFirstStamp: true
+        },
+        effectCounter: "seqAdvanced",
+        note: "column, not attr; measured over nodes born since the first stamp in the recent window"
+      },
+      {
+        id: "render-ledger",
+        what: "records which priors actually reached the agent, so an answer rate has a denominator",
+        // RENDER, not semantic-maintenance — `shown` only moves during a render, so
+        // attributing it elsewhere named an always-zero counter (same defect as
+        // ingest-sequence's, found alongside it).
+        pass: "render",
+        fed: {
+          labels: ["Problem", "Solution", "RootCause", "Pattern"],
+          attr: "shownCount",
+          minFraction: 5e-3
+        },
+        effectCounter: "shown"
+      },
+      {
+        id: "orphan-reap",
+        what: "closes File nodes whose path the indexer no longer covers",
+        pass: "orphan-reap",
+        // Stranded lineage is the CONDITION this clears, so a rising reading is bad;
+        // it is declared fed-by-liveness so the row exists and the pass is watched.
+        fed: { labels: ["File"], attr: "relPath", minFraction: 0.9 },
+        effectCounter: "reaped"
+      }
+    ];
+    COLUMN_INPUTS = {
+      __createdAtSeq: (n) => n.createdAtSeq !== void 0 && n.createdAtSeq !== null
+    };
+  }
+});
+
 // ../../packages/local-graph/src/index.ts
 var src_exports2 = {};
 __export(src_exports2, {
@@ -21812,12 +22012,15 @@ __export(src_exports2, {
   JOINT_COMMUNITY_EDGES: () => JOINT_COMMUNITY_EDGES,
   JOINT_COMMUNITY_LABELS: () => JOINT_COMMUNITY_LABELS,
   MAX_ANCHOR_FILES: () => MAX_ANCHOR_FILES,
+  MECHANISMS: () => MECHANISMS,
   MIN_INTENT_TOKENS: () => MIN_INTENT_TOKENS,
   PATTERN_DEDUP_COSINE: () => PATTERN_DEDUP_COSINE,
   PERCOLATING_DRIFT_EDGES: () => PERCOLATING_DRIFT_EDGES,
   PERCOLATING_EDGES: () => PERCOLATING_EDGES,
   PERCOLATING_LABELS: () => PERCOLATING_LABELS,
   SAME_ANCHOR_DEDUP_JACCARD: () => SAME_ANCHOR_DEDUP_JACCARD,
+  STALL_MIN_RUNS: () => STALL_MIN_RUNS,
+  STALL_MIN_SPAN_MS: () => STALL_MIN_SPAN_MS,
   SqliteGraphStore: () => SqliteGraphStore,
   addDependency: () => addDependency,
   aggregateClaimConfidence: () => aggregateClaimConfidence,
@@ -21851,14 +22054,18 @@ __export(src_exports2, {
   detectLocalCommunities: () => detectLocalCommunities,
   edgeConductance: () => edgeConductance,
   evaluateDependency: () => evaluateDependency,
+  evaluateFed: () => evaluateFed,
+  evaluateMechanisms: () => evaluateMechanisms,
   findMintTimeDuplicate: () => findMintTimeDuplicate,
   findOrCreatePackage: () => findOrCreatePackage,
   findPath: () => findPath,
   flattenCloudCounts: () => flattenCloudCounts,
   foldDuplicateProblem: () => foldDuplicateProblem,
+  formatMechanismStatus: () => formatMechanismStatus,
   getClaim: () => getClaim,
   harvestAbstractionFences: () => harvestAbstractionFences,
   harvestTriageFences: () => harvestTriageFences,
+  hasStarvedMechanism: () => hasStarvedMechanism,
   induceAbstractions: () => induceAbstractions,
   induceTriage: () => induceTriage,
   ingestDesignProblem: () => ingestDesignProblem,
@@ -21948,6 +22155,7 @@ var init_src5 = __esm({
     init_problem_package_link();
     init_tools();
     init_principle_sync();
+    init_mechanism_liveness();
   }
 });
 
@@ -28477,7 +28685,7 @@ var init_motifs = __esm({
 });
 
 // ../../packages/generalizer/src/nightly.ts
-function runNightlyPipeline(store) {
+function runGraphRescore(store) {
   const started2 = Date.now();
   const allowedTypes = new Set(pagerankEdgeTypes());
   const nodeIds = [];
@@ -28560,11 +28768,6 @@ function runNightlyPipeline(store) {
     for (const [id, c] of comm.community) store.updateNode(id, { community: c });
   });
   const motifs = promoteMotifs(store, started2);
-  reopenAutoClosedProblems(store, started2);
-  const revisits = clearAnsweredRevisits(store, started2);
-  const fixCandidates = clearSettledFixCandidates(store, started2);
-  const designResolved = markFixCandidates(store, started2);
-  const cry = crystallize(store, { ts: started2 });
   return {
     scoredNodes: scored,
     iterations: result.iterations,
@@ -28574,17 +28777,51 @@ function runNightlyPipeline(store) {
     motifsPromoted: motifs.promoted,
     techniques: motifs.techniques,
     antipatterns: motifs.antipatterns,
-    skillsInduced: 0,
-    // skills are cloud-induced now (see above)
-    skillsRefreshed: 0,
+    durationMs: Date.now() - started2
+  };
+}
+function runSemanticMaintenance(store) {
+  const started2 = Date.now();
+  reopenAutoClosedProblems(store, started2);
+  const revisits = clearAnsweredRevisits(store, started2);
+  const fixCandidates = clearSettledFixCandidates(store, started2);
+  const designResolved = markFixCandidates(store, started2);
+  const cry = crystallize(store, { ts: started2 });
+  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() - started2
   };
 }
+function runNightlyPipeline(store) {
+  const started2 = Date.now();
+  const rescore = runGraphRescore(store);
+  const semantic = runSemanticMaintenance(store);
+  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,
+    designResolved: semantic.designResolved,
+    revisitsCleared: semantic.revisitsCleared,
+    fixCandidatesSettled: semantic.fixCandidatesSettled,
+    claimsEvaluated: semantic.claimsEvaluated,
+    claimsDerived: semantic.claimsDerived,
+    durationMs: Date.now() - started2
+  };
+}
 function codeAnchorProjection(store, semanticIds, opts = {}) {
   const anchorToNodes = /* @__PURE__ */ new Map();
   for (const id of semanticIds) {
@@ -28874,7 +29111,9 @@ __export(src_exports4, {
   reconcileDiagnostics: () => reconcileDiagnostics,
   resolveProblem: () => resolveProblem,
   runGeneralizer: () => runGeneralizer,
+  runGraphRescore: () => runGraphRescore,
   runNightlyPipeline: () => runNightlyPipeline,
+  runSemanticMaintenance: () => runSemanticMaintenance,
   scoreCandidate: () => scoreCandidate,
   selectAnchorFrame: () => selectAnchorFrame
 });
@@ -30357,7 +30596,7 @@ async function scan(root, current, ignores, providers, out2) {
     }
   }
 }
-function gitListFiles(root, ignores, providers) {
+function gitListRelPaths(root, ignores) {
   let stdout;
   try {
     stdout = execFileSync(
@@ -30380,6 +30619,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 = join8(root, rel);
     let size;
     try {
@@ -37719,6 +37967,7 @@ var init_csharp_treesitter = __esm({
 // ../../packages/indexer/src/index.ts
 var src_exports5 = {};
 __export(src_exports5, {
+  DEFAULT_IGNORES: () => DEFAULT_IGNORES,
   DRIFT_FORK_RATIO: () => DRIFT_FORK_RATIO,
   TreeSitterCSharpProvider: () => TreeSitterCSharpProvider,
   TreeSitterCppProvider: () => TreeSitterCppProvider,
@@ -37735,6 +37984,7 @@ __export(src_exports5, {
   findInnermostScope: () => findInnermostScope,
   folderNodeId: () => folderNodeId,
   fromHex: () => fromHex,
+  gitListRelPaths: () => gitListRelPaths,
   hammingDistance: () => hammingDistance,
   hasForkedDrift: () => hasForkedDrift,
   incrementalReindex: () => incrementalReindex,
@@ -37847,6 +38097,8 @@ async function findStaleFiles(store, rootPath, workspaceId2) {
     const fnode = store.getNode(fileNodeId(workspaceId2, rel));
     if (!fnode) {
       stale.push(abs);
+    } else if ((fnode.validTo ?? null) !== null) {
+      stale.push(abs);
     } else if (fnode.lastUpdatedAt < mtimeMs) {
       stale.push(abs);
     } else {
@@ -37882,19 +38134,67 @@ function findStrandedSymbols(store) {
   }
   return stranded;
 }
+function reapOrphanedFiles(store, rootPath, workspaceId2, ignoreDirs = []) {
+  const ignores = /* @__PURE__ */ new Set([...DEFAULT_IGNORES, ...ignoreDirs]);
+  const listed = gitListRelPaths(rootPath, ignores);
+  if (listed === null) return { reaped: 0, symbolsClosed: 0, skipped: "no-git-listing" };
+  if (listed.length === 0) return { reaped: 0, symbolsClosed: 0, skipped: "empty-listing" };
+  const onDisk = new Set(listed);
+  const live = store.findNodesByLabel("File").filter((f) => f.attrs["workspaceId"] === workspaceId2);
+  const orphans = live.filter((f) => {
+    const rel = f.attrs["relPath"];
+    return typeof rel === "string" && !onDisk.has(rel);
+  });
+  const allowance = Math.max(ORPHAN_REAP_MIN_ALLOWANCE, live.length * ORPHAN_REAP_MAX_FRACTION);
+  if (orphans.length > allowance) {
+    return {
+      reaped: 0,
+      symbolsClosed: 0,
+      skipped: "over-fraction",
+      candidates: orphans.length
+    };
+  }
+  const t = Date.now();
+  let symbolsClosed = 0;
+  store.transaction(() => {
+    for (const f of orphans) {
+      for (const e of store.outEdges(f.id, ["DEFINES", "CONTAINS"])) {
+        store.closeEdge(e.id, t);
+        const sym = store.getNode(e.to);
+        if (sym && (sym.validTo ?? null) === null) {
+          store.closeNode(sym.id, t);
+          symbolsClosed++;
+        }
+      }
+      store.closeNode(f.id, t);
+    }
+  });
+  return { reaped: orphans.length, symbolsClosed };
+}
 async function reconcileStaleFiles(store, rootPath, workspaceId2) {
   const stale = await findStaleFiles(store, rootPath, workspaceId2);
   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(store, rootPath, workspaceId2, stale.slice(i2, i2 + BATCH));
-    total += r.filesReindexed;
+    try {
+      const r = await incrementalReindex(store, rootPath, workspaceId2, 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;
 }
-var IGNORED, SOURCE_RE, SCAN_YIELD_EVERY, LIVENESS_CHUNK;
+var IGNORED, SOURCE_RE, SCAN_YIELD_EVERY, LIVENESS_CHUNK, ORPHAN_REAP_MAX_FRACTION, ORPHAN_REAP_MIN_ALLOWANCE;
 var init_reconcile = __esm({
   "src/reconcile.ts"() {
     "use strict";
@@ -37903,6 +38203,8 @@ var init_reconcile = __esm({
     SOURCE_RE = /\.(ts|tsx|js|jsx|mjs|cjs|py)$/i;
     SCAN_YIELD_EVERY = 100;
     LIVENESS_CHUNK = 4e3;
+    ORPHAN_REAP_MAX_FRACTION = 0.25;
+    ORPHAN_REAP_MIN_ALLOWANCE = 50;
   }
 });
 
@@ -48066,27 +48368,27 @@ __export(witness_ledger_exports, {
   summarizeWitnessLedger: () => summarizeWitnessLedger,
   witnessLedgerPath: () => witnessLedgerPath
 });
-import { appendFileSync as appendFileSync2, existsSync as existsSync20, readFileSync as readFileSync20, writeFileSync as writeFileSync17 } from "node:fs";
-import { join as join25 } from "node:path";
+import { appendFileSync as appendFileSync3, existsSync as existsSync21, readFileSync as readFileSync21, writeFileSync as writeFileSync18 } from "node:fs";
+import { join as join26 } from "node:path";
 function witnessLedgerPath(configDir) {
-  return join25(configDir, "witness-ledger.jsonl");
+  return join26(configDir, "witness-ledger.jsonl");
 }
 function appendWitnessLedger(configDir, entry) {
   const path2 = witnessLedgerPath(configDir);
   try {
-    appendFileSync2(path2, JSON.stringify(entry) + "\n");
-    const lines = readFileSync20(path2, "utf8").split("\n").filter(Boolean);
+    appendFileSync3(path2, JSON.stringify(entry) + "\n");
+    const lines = readFileSync21(path2, "utf8").split("\n").filter(Boolean);
     if (lines.length > LEDGER_MAX_LINES) {
-      writeFileSync17(path2, lines.slice(-Math.floor(LEDGER_MAX_LINES / 2)).join("\n") + "\n");
+      writeFileSync18(path2, lines.slice(-Math.floor(LEDGER_MAX_LINES / 2)).join("\n") + "\n");
     }
   } catch {
   }
 }
 function readWitnessLedger(configDir) {
   const path2 = witnessLedgerPath(configDir);
-  if (!existsSync20(path2)) return [];
+  if (!existsSync21(path2)) return [];
   try {
-    return readFileSync20(path2, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter((e) => typeof e.ts === "number" && typeof e.channel === "string");
+    return readFileSync21(path2, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter((e) => typeof e.ts === "number" && typeof e.channel === "string");
   } catch {
     return [];
   }
@@ -48512,12 +48814,12 @@ var init_report_render = __esm({
 
 // src/cli.ts
 init_src6();
-import { closeSync as closeSync2, existsSync as existsSync27, openSync as openSync2, readFileSync as readFileSync26, renameSync as renameSync4, statSync as statSync6 } from "node:fs";
-import { join as join30 } from "node:path";
+import { closeSync as closeSync2, existsSync as existsSync28, openSync as openSync2, readFileSync as readFileSync27, renameSync as renameSync4, statSync as statSync6 } from "node:fs";
+import { join as join31 } from "node:path";
 import { spawn as spawn3 } from "node:child_process";
 
 // src/daemon.ts
-import { existsSync as existsSync22, writeFileSync as writeFileSync19 } from "node:fs";
+import { existsSync as existsSync23, writeFileSync as writeFileSync20 } from "node:fs";
 
 // ../../node_modules/.pnpm/@hono+node-server@1.19.11_hono@4.12.8/node_modules/@hono/node-server/dist/index.mjs
 import { createServer as createServerHTTP } from "http";
@@ -49097,8 +49399,8 @@ init_config();
 
 // src/engine.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync21, statSync as statSync5, appendFileSync as appendFileSync3, readdirSync as readdirSync9, renameSync as renameSync3, readFileSync as readFileSync21, writeFileSync as writeFileSync18 } from "node:fs";
-import { join as join26, relative as relative6, sep as sep4 } from "node:path";
+import { existsSync as existsSync22, statSync as statSync5, appendFileSync as appendFileSync4, readdirSync as readdirSync9, renameSync as renameSync3, readFileSync as readFileSync22, writeFileSync as writeFileSync19 } from "node:fs";
+import { join as join27, relative as relative6, sep as sep4 } from "node:path";
 
 // ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -52197,6 +52499,48 @@ function repairInvalidEdges(store, opts) {
 init_symbol_summaries();
 init_reconcile();
 
+// src/pass-ledger.ts
+import { appendFileSync as appendFileSync2, existsSync as existsSync15, readFileSync as readFileSync13, writeFileSync as writeFileSync13 } from "node:fs";
+import { join as join18 } from "node:path";
+var PER_KIND_MAX = 100;
+var TRIM_EVERY = 50;
+var appendsSinceTrim = /* @__PURE__ */ new Map();
+function passLedgerPath(configDir) {
+  return join18(configDir, "pass-ledger.jsonl");
+}
+function appendPassLedger(configDir, kind, durationMs, counts) {
+  const path2 = passLedgerPath(configDir);
+  try {
+    const entry = { ts: Date.now(), kind, durationMs, counts };
+    appendFileSync2(path2, JSON.stringify(entry) + "\n");
+    const n = (appendsSinceTrim.get(path2) ?? 0) + 1;
+    if (n < TRIM_EVERY) {
+      appendsSinceTrim.set(path2, n);
+      return;
+    }
+    appendsSinceTrim.set(path2, 0);
+    const lines = readFileSync13(path2, "utf8").split("\n").filter(Boolean);
+    const keptByKind = /* @__PURE__ */ new Map();
+    const kept = [];
+    for (let i2 = lines.length - 1; i2 >= 0; i2--) {
+      let kind2;
+      try {
+        kind2 = String(JSON.parse(lines[i2]).kind ?? "");
+      } catch {
+        continue;
+      }
+      const n2 = keptByKind.get(kind2) ?? 0;
+      if (n2 >= PER_KIND_MAX) continue;
+      keptByKind.set(kind2, n2 + 1);
+      kept.push(lines[i2]);
+    }
+    if (kept.length < lines.length) {
+      writeFileSync13(path2, kept.reverse().join("\n") + "\n");
+    }
+  } catch {
+  }
+}
+
 // src/episode.ts
 init_src();
 function deltaIsEmpty(d) {
@@ -52391,11 +52735,11 @@ init_outbox();
 init_src9();
 init_src();
 init_src2();
-import { readFileSync as readFileSync13 } from "node:fs";
-import { join as join18 } from "node:path";
+import { readFileSync as readFileSync14 } from "node:fs";
+import { join as join19 } from "node:path";
 function loadClaimIgnorePatterns(workspaceRoot) {
   try {
-    return readFileSync13(join18(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
+    return readFileSync14(join19(workspaceRoot, ".errataignore"), "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#")).map((l) => l.toLowerCase());
   } catch {
     return [];
   }
@@ -52756,22 +53100,22 @@ async function pullCloudTriage(shared, cloud, profile, limit = 50) {
 }
 
 // src/git-sensor.ts
-import { existsSync as existsSync15, readFileSync as readFileSync14, watch as fsWatch } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync16, readFileSync as readFileSync15, watch as fsWatch } from "node:fs";
+import { join as join20 } from "node:path";
 function readFirstLine(path2) {
   try {
-    return readFileSync14(path2, "utf8").split(/\r?\n/, 1)[0].trim();
+    return readFileSync15(path2, "utf8").split(/\r?\n/, 1)[0].trim();
   } catch {
     return null;
   }
 }
 function readGitRefState(gitDir) {
-  const head2 = readFirstLine(join19(gitDir, "HEAD"));
+  const head2 = readFirstLine(join20(gitDir, "HEAD"));
   const m = head2 ? /^ref:\s*refs\/heads\/(.+)$/.exec(head2) : null;
   const branch = m ? m[1] : null;
   let sha2 = null;
   if (branch) {
-    sha2 = readFirstLine(join19(gitDir, "refs", "heads", branch));
+    sha2 = readFirstLine(join20(gitDir, "refs", "heads", branch));
     if (!sha2) sha2 = shaFromPackedRefs(gitDir, `refs/heads/${branch}`);
   } else if (head2 && /^[0-9a-f]{7,40}$/i.test(head2)) {
     sha2 = head2;
@@ -52779,13 +53123,13 @@ function readGitRefState(gitDir) {
   return {
     branch,
     sha: sha2,
-    mergeHeadExists: existsSync15(join19(gitDir, "MERGE_HEAD")),
-    origHeadExists: existsSync15(join19(gitDir, "ORIG_HEAD"))
+    mergeHeadExists: existsSync16(join20(gitDir, "MERGE_HEAD")),
+    origHeadExists: existsSync16(join20(gitDir, "ORIG_HEAD"))
   };
 }
 function shaFromPackedRefs(gitDir, ref) {
   try {
-    for (const line of readFileSync14(join19(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
+    for (const line of readFileSync15(join20(gitDir, "packed-refs"), "utf8").split(/\r?\n/)) {
       const [sha2, name2] = line.split(/\s+/);
       if (name2 === ref && sha2) return sha2;
     }
@@ -52819,7 +53163,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
   const settle = () => {
     if (timer) clearTimeout(timer);
     timer = setTimeout(() => {
-      if (existsSync15(join19(gitDir, "index.lock"))) {
+      if (existsSync16(join20(gitDir, "index.lock"))) {
         settle();
         return;
       }
@@ -52830,7 +53174,7 @@ function startGitSensor(gitDir, onEvent, opts = {}) {
     }, debounceMs);
   };
   for (const sub of ["HEAD", "logs/HEAD", "MERGE_HEAD", "ORIG_HEAD"]) {
-    const p = join19(gitDir, sub);
+    const p = join20(gitDir, sub);
     try {
       watchers.push(fsWatch(p, settle));
     } catch {
@@ -53055,21 +53399,21 @@ var TelemetryRecorder = class {
 
 // src/skills.ts
 import {
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   mkdirSync as mkdirSync6,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   readdirSync as readdirSync7,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync13
+  writeFileSync as writeFileSync14
 } from "node:fs";
-import { basename as basename4, join as join20 } from "node:path";
+import { basename as basename4, join as join21 } from "node:path";
 function skillFileName(id) {
   return `${id.replace(/[^A-Za-z0-9_.-]/g, "_")}.md`;
 }
 function readSkillManifest(manifestPath) {
-  if (!existsSync16(manifestPath)) return [];
+  if (!existsSync17(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync15(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync16(manifestPath, "utf8"));
     return (parsed.skills ?? []).map((s) => ({
       title: s.title ?? "",
       layer: s.layer ?? "technique",
@@ -53093,7 +53437,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
   for (const s of res.skills) {
     const fileName = skillFileName(s.id);
     keep.add(fileName);
-    writeFileSync13(join20(paths.skillsDir, fileName), s.markdown, "utf8");
+    writeFileSync14(join21(paths.skillsDir, fileName), s.markdown, "utf8");
     rows.push({
       id: s.id,
       title: s.title,
@@ -53106,7 +53450,7 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
     const fileName = skillFileName(p.id);
     if (keep.has(fileName)) continue;
     keep.add(fileName);
-    writeFileSync13(join20(paths.skillsDir, fileName), p.markdown, "utf8");
+    writeFileSync14(join21(paths.skillsDir, fileName), p.markdown, "utf8");
     rows.push({
       id: p.id,
       title: p.title,
@@ -53120,13 +53464,13 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
     if (!f.endsWith(".md")) continue;
     if (keep.has(basename4(f))) continue;
     try {
-      unlinkSync2(join20(paths.skillsDir, f));
+      unlinkSync2(join21(paths.skillsDir, f));
       pruned++;
     } catch {
     }
   }
   rows.sort((a, b) => a.id.localeCompare(b.id));
-  writeFileSync13(
+  writeFileSync14(
     paths.skillsManifest,
     JSON.stringify({ generatedAt: Date.now(), skills: rows }, null, 2),
     "utf8"
@@ -53138,22 +53482,22 @@ async function syncSkills(paths, client, seed, pins = [], techSeed) {
 init_src2();
 import {
   cpSync,
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   lstatSync,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   readdirSync as readdirSync8,
   rmSync as rmSync2,
   symlinkSync,
-  writeFileSync as writeFileSync14
+  writeFileSync as writeFileSync15
 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 var SKILL_NS = "errata-";
 var HARNESS_SKILL_DIRS = [
-  { configDir: ".claude", skillsDir: join21(".claude", "skills") },
+  { configDir: ".claude", skillsDir: join22(".claude", "skills") },
   // Cursor adopted the standard; its exact project dir is still moving — kept
   // best-effort and gated on `.cursor/` presence so we never create it blind.
-  { configDir: ".cursor", skillsDir: join21(".cursor", "skills") }
+  { configDir: ".cursor", skillsDir: join22(".cursor", "skills") }
 ];
 function skillSlug(title, id) {
   const base = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || id.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "skill";
@@ -53198,12 +53542,12 @@ function skillCiteHandle(s) {
   return priorHandle({ id: s.id, description: s.title });
 }
 function reconcileNamespaced(dir, keep) {
-  if (!existsSync17(dir)) return 0;
+  if (!existsSync18(dir)) return 0;
   let pruned = 0;
   for (const name2 of readdirSync8(dir)) {
     if (!name2.startsWith(SKILL_NS) || keep.has(name2)) continue;
     try {
-      rmSync2(join21(dir, name2), { recursive: true, force: true });
+      rmSync2(join22(dir, name2), { recursive: true, force: true });
       pruned++;
     } catch {
     }
@@ -53212,7 +53556,7 @@ function reconcileNamespaced(dir, keep) {
 }
 function linkOrCopy(linkPath, target) {
   try {
-    if (existsSync17(linkPath) || safeLstat(linkPath)) rmSync2(linkPath, { recursive: true, force: true });
+    if (existsSync18(linkPath) || safeLstat(linkPath)) rmSync2(linkPath, { recursive: true, force: true });
   } catch {
   }
   try {
@@ -53233,7 +53577,7 @@ function safeLstat(p) {
   }
 }
 function emitAndProjectSkills(root, skills) {
-  const agentsSkillsDir = join21(root, ".agents", "skills");
+  const agentsSkillsDir = join22(root, ".agents", "skills");
   mkdirSync7(agentsSkillsDir, { recursive: true });
   const slugs = [];
   const keep = /* @__PURE__ */ new Set();
@@ -53241,7 +53585,7 @@ function emitAndProjectSkills(root, skills) {
   for (const s of skills) {
     let body2;
     try {
-      body2 = readFileSync16(s.bodyPath, "utf8");
+      body2 = readFileSync17(s.bodyPath, "utf8");
     } catch {
       continue;
     }
@@ -53250,9 +53594,9 @@ function emitAndProjectSkills(root, skills) {
     keep.add(slug2);
     slugs.push(slug2);
     const description = deriveDescription(s.title, s.layer, body2);
-    mkdirSync7(join21(agentsSkillsDir, slug2), { recursive: true });
-    writeFileSync14(
-      join21(agentsSkillsDir, slug2, "SKILL.md"),
+    mkdirSync7(join22(agentsSkillsDir, slug2), { recursive: true });
+    writeFileSync15(
+      join22(agentsSkillsDir, slug2, "SKILL.md"),
       renderSkillMd(slug2, description, body2, skillCiteHandle(s)),
       "utf8"
     );
@@ -53261,11 +53605,11 @@ function emitAndProjectSkills(root, skills) {
   reconcileNamespaced(agentsSkillsDir, keep);
   let projected = 0;
   for (const h of HARNESS_SKILL_DIRS) {
-    if (!existsSync17(join21(root, h.configDir))) continue;
-    const dir = join21(root, h.skillsDir);
+    if (!existsSync18(join22(root, h.configDir))) continue;
+    const dir = join22(root, h.skillsDir);
     mkdirSync7(dir, { recursive: true });
     for (const slug2 of slugs) {
-      linkOrCopy(join21(dir, slug2), join21(agentsSkillsDir, slug2));
+      linkOrCopy(join22(dir, slug2), join22(agentsSkillsDir, slug2));
       projected++;
     }
     reconcileNamespaced(dir, keep);
@@ -53274,15 +53618,15 @@ function emitAndProjectSkills(root, skills) {
   return { slugs, emitted, projected };
 }
 function emitInputsFromManifest(erretaDir, manifestPath) {
-  if (!existsSync17(manifestPath)) return [];
+  if (!existsSync18(manifestPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync16(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync17(manifestPath, "utf8"));
     return (parsed.skills ?? []).filter((s) => Boolean(s.id && s.file)).map((s) => ({
       id: s.id,
       title: s.title ?? s.id,
       layer: s.layer ?? "technique",
       confidence: s.confidence ?? 0,
-      bodyPath: join21(erretaDir, s.file)
+      bodyPath: join22(erretaDir, s.file)
     }));
   } catch {
     return [];
@@ -53296,17 +53640,17 @@ var GITIGNORE_LINES = [
   ".cursor/skills/errata-*/"
 ];
 function ensureSkillGitignore(root) {
-  const path2 = join21(root, ".gitignore");
+  const path2 = join22(root, ".gitignore");
   let current = "";
   try {
-    current = existsSync17(path2) ? readFileSync16(path2, "utf8") : "";
+    current = existsSync18(path2) ? readFileSync17(path2, "utf8") : "";
   } catch {
     return;
   }
   if (current.includes(GITIGNORE_MARK)) return;
   const prefix = current.length > 0 && !current.endsWith("\n") ? "\n" : "";
   try {
-    writeFileSync14(path2, `${current}${prefix}
+    writeFileSync15(path2, `${current}${prefix}
 ${GITIGNORE_LINES.join("\n")}
 `, "utf8");
   } catch {
@@ -53399,20 +53743,20 @@ init_paths();
 // src/profile.ts
 init_src2();
 init_paths();
-import { existsSync as existsSync19, readFileSync as readFileSync18, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync20, readFileSync as readFileSync19, writeFileSync as writeFileSync16 } from "node:fs";
 import { createHash as createHash12 } from "node:crypto";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 
 // src/git-remote.ts
 init_src();
-import { existsSync as existsSync18, readFileSync as readFileSync17, statSync as statSync4 } from "node:fs";
-import { isAbsolute as isAbsolute3, join as join22, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync19, readFileSync as readFileSync18, statSync as statSync4 } from "node:fs";
+import { isAbsolute as isAbsolute3, join as join23, resolve as resolve5 } from "node:path";
 function resolveGitDir(root) {
-  const dotGit = join22(root, ".git");
+  const dotGit = join23(root, ".git");
   try {
     const st = statSync4(dotGit);
     if (st.isDirectory()) return dotGit;
-    const m = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync17(dotGit, "utf8"));
+    const m = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync18(dotGit, "utf8"));
     if (!m) return null;
     const dir = m[1];
     return isAbsolute3(dir) ? dir : resolve5(root, dir);
@@ -53421,22 +53765,22 @@ function resolveGitDir(root) {
   }
 }
 function gitConfigPath(gitDir) {
-  const commondirFile = join22(gitDir, "commondir");
-  if (existsSync18(commondirFile)) {
-    const common = readFileSync17(commondirFile, "utf8").trim();
+  const commondirFile = join23(gitDir, "commondir");
+  if (existsSync19(commondirFile)) {
+    const common = readFileSync18(commondirFile, "utf8").trim();
     const commonDir = isAbsolute3(common) ? common : resolve5(gitDir, common);
-    return join22(commonDir, "config");
+    return join23(commonDir, "config");
   }
-  return join22(gitDir, "config");
+  return join23(gitDir, "config");
 }
 function readRemotes(root) {
   const gitDir = resolveGitDir(root);
   if (!gitDir) return [];
   const cfgPath = gitConfigPath(gitDir);
-  if (!existsSync18(cfgPath)) return [];
+  if (!existsSync19(cfgPath)) return [];
   let txt;
   try {
-    txt = readFileSync17(cfgPath, "utf8");
+    txt = readFileSync18(cfgPath, "utf8");
   } catch {
     return [];
   }
@@ -53478,13 +53822,13 @@ function refreshRepoLocator(root, profile) {
 }
 function loadProfile(root) {
   const p = workspacePaths(root);
-  if (!existsSync19(p.workspaceJson)) return null;
-  return JSON.parse(readFileSync18(p.workspaceJson, "utf8"));
+  if (!existsSync20(p.workspaceJson)) return null;
+  return JSON.parse(readFileSync19(p.workspaceJson, "utf8"));
 }
 function saveProfile(root, profile) {
   const p = workspacePaths(root);
   ensureDir(p.configDir);
-  writeFileSync15(p.workspaceJson, JSON.stringify(profile, null, 2), "utf8");
+  writeFileSync16(p.workspaceJson, JSON.stringify(profile, null, 2), "utf8");
 }
 function autodetectProfile(root) {
   const id = workspaceId(root);
@@ -53492,10 +53836,10 @@ function autodetectProfile(root) {
   const p = emptyProfile(id, name2);
   const locator = detectRepoLocator(root);
   if (locator) p.repoLocator = locator;
-  const pkgPath = join23(root, "package.json");
-  if (existsSync19(pkgPath)) {
+  const pkgPath = join24(root, "package.json");
+  if (existsSync20(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync18(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync19(pkgPath, "utf8"));
       p.languages.push("typescript", "javascript");
       const nodeVer = pkg.engines?.node ?? "node";
       p.stack.push(`node@${nodeVer}`);
@@ -53516,10 +53860,10 @@ function autodetectProfile(root) {
     } catch {
     }
   }
-  const pyproject = join23(root, "pyproject.toml");
-  if (existsSync19(pyproject)) {
+  const pyproject = join24(root, "pyproject.toml");
+  if (existsSync20(pyproject)) {
     try {
-      const txt = readFileSync18(pyproject, "utf8");
+      const txt = readFileSync19(pyproject, "utf8");
       const py = /python\s*=\s*"([^"]+)"/.exec(txt)?.[1];
       p.languages.push("python");
       p.stack.push(`python@${py ?? "3"}`);
@@ -53530,16 +53874,16 @@ function autodetectProfile(root) {
     } catch {
     }
   }
-  const reqs = join23(root, "requirements.txt");
-  if (existsSync19(reqs)) {
+  const reqs = join24(root, "requirements.txt");
+  if (existsSync20(reqs)) {
     if (!p.languages.includes("python")) p.languages.push("python");
     if (!p.stack.includes("python@3")) p.stack.push("python@3");
   }
-  if (existsSync19(join23(root, "go.mod"))) {
+  if (existsSync20(join24(root, "go.mod"))) {
     p.languages.push("go");
     p.stack.push("go");
   }
-  if (existsSync19(join23(root, "Cargo.toml"))) {
+  if (existsSync20(join24(root, "Cargo.toml"))) {
     p.languages.push("rust");
     p.stack.push("rust");
   }
@@ -53549,17 +53893,17 @@ function autodetectProfile(root) {
 }
 
 // src/witness-queue.ts
-import { readFileSync as readFileSync19, renameSync as renameSync2, writeFileSync as writeFileSync16 } from "node:fs";
-import { dirname as dirname9, join as join24 } from "node:path";
+import { readFileSync as readFileSync20, renameSync as renameSync2, writeFileSync as writeFileSync17 } from "node:fs";
+import { dirname as dirname9, join as join25 } from "node:path";
 var WITNESS_QUEUE_CAP = 500;
 var WITNESS_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
 var WITNESS_MAX_ATTEMPTS = 5;
 function witnessQueuePath(workspaceConfigDir) {
-  return join24(workspaceConfigDir, "witness-queue.json");
+  return join25(workspaceConfigDir, "witness-queue.json");
 }
 function loadWitnessQueue(path2) {
   try {
-    const raw2 = JSON.parse(readFileSync19(path2, "utf8"));
+    const raw2 = JSON.parse(readFileSync20(path2, "utf8"));
     if (!Array.isArray(raw2)) return [];
     return raw2.filter(
       (w) => !!w && typeof w === "object" && typeof w.nodeId === "string" && typeof w.witnessKey === "string"
@@ -53570,8 +53914,8 @@ function loadWitnessQueue(path2) {
 }
 function saveWitnessQueue(path2, queue) {
   try {
-    const tmp = join24(dirname9(path2), `.${Date.now()}.witness-queue.tmp`);
-    writeFileSync16(tmp, JSON.stringify(queue), "utf8");
+    const tmp = join25(dirname9(path2), `.${Date.now()}.witness-queue.tmp`);
+    writeFileSync17(tmp, JSON.stringify(queue), "utf8");
     renameSync2(tmp, path2);
   } catch {
   }
@@ -53862,7 +54206,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.517" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.532" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -53872,17 +54216,17 @@ var TURN_REPLAY_LOOKBACK_MS = 7 * 24 * 60 * 6e4;
 function appendIdentityAudit(path2, record2, line) {
   if (!record2.accepted && record2.score <= 0) return;
   try {
-    if (existsSync21(path2) && statSync5(path2).size >= IDENTITY_AUDIT_MAX_BYTES) {
+    if (existsSync22(path2) && statSync5(path2).size >= IDENTITY_AUDIT_MAX_BYTES) {
       renameSync3(path2, `${path2}.1`);
     }
-    appendFileSync3(path2, line);
+    appendFileSync4(path2, line);
   } catch {
   }
 }
 var yieldToLoop = () => new Promise((r) => setImmediate(r));
 function loadTurnCursors(path2) {
   try {
-    const raw2 = JSON.parse(readFileSync21(path2, "utf8"));
+    const raw2 = JSON.parse(readFileSync22(path2, "utf8"));
     return new Map(
       Object.entries(raw2).map(([k, v]) => [k, typeof v === "string" ? v : String(v?.uuid ?? "")])
     );
@@ -53892,7 +54236,7 @@ function loadTurnCursors(path2) {
 }
 function loadTurnOffsets(path2) {
   try {
-    const raw2 = JSON.parse(readFileSync21(path2, "utf8"));
+    const raw2 = JSON.parse(readFileSync22(path2, "utf8"));
     const out2 = /* @__PURE__ */ new Map();
     for (const [k, v] of Object.entries(raw2)) {
       const off = typeof v === "object" && v !== null ? v.offset : void 0;
@@ -53908,7 +54252,7 @@ function saveTurnCursors(path2, cursors, offsets) {
     const merged = {};
     for (const [k, uuid3] of cursors) merged[k] = { uuid: uuid3, offset: offsets.get(k) ?? 0 };
     for (const [k, offset] of offsets) if (!merged[k]) merged[k] = { uuid: "", offset };
-    writeFileSync18(path2, JSON.stringify(merged), "utf8");
+    writeFileSync19(path2, JSON.stringify(merged), "utf8");
   } catch {
   }
 }
@@ -53930,7 +54274,7 @@ function gitSourceWatchTargets(root) {
         ["-C", root, "ls-files", "--others", "--ignored", "--exclude-standard", "--directory", "-z"],
         { encoding: "utf8", maxBuffer: 256 * 1024 * 1024, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] }
       );
-      ignoredDirs = igOut.split("\0").filter(Boolean).map((d) => d.replace(/\/+$/, "")).filter((d) => !IGNORED_PATH.test(join26(root, d) + sep4));
+      ignoredDirs = igOut.split("\0").filter(Boolean).map((d) => d.replace(/\/+$/, "")).filter((d) => !IGNORED_PATH.test(join27(root, d) + sep4));
     } catch {
     }
     const hasIgnoredChild = (dir) => ignoredDirs.some((ig) => ig.startsWith(dir + "/"));
@@ -53942,19 +54286,19 @@ function gitSourceWatchTargets(root) {
         if (!f.startsWith(prefix)) continue;
         const rest2 = f.slice(prefix.length);
         if (rest2.includes("/")) children.add(dir === "" ? rest2.slice(0, rest2.indexOf("/")) : dir + "/" + rest2.slice(0, rest2.indexOf("/")));
-        else targets.add(join26(root, f));
+        else targets.add(join27(root, f));
       }
       for (const c of children) {
-        if (IGNORED_PATH.test(join26(root, c) + sep4)) continue;
+        if (IGNORED_PATH.test(join27(root, c) + sep4)) continue;
         if (hasIgnoredChild(c)) addUnder(c);
-        else targets.add(join26(root, c));
+        else targets.add(join27(root, c));
       }
     };
     addUnder("");
     if (targets.size > 0) return [...targets];
   } catch {
   }
-  return readdirSync9(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !IGNORED_PATH.test(join26(root, String(e.name)) + sep4)).map((e) => join26(root, String(e.name)));
+  return readdirSync9(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !IGNORED_PATH.test(join27(root, String(e.name)) + sep4)).map((e) => join27(root, String(e.name)));
 }
 function createWorkspaceEngine(opts) {
   const paths = workspacePaths(opts.workspaceRoot);
@@ -54112,7 +54456,7 @@ function createWorkspaceEngine(opts) {
       const srcPaths = diff.changedPaths.filter((p) => /\.(ts|tsx|js|jsx|mjs|cjs|py)$/i.test(p));
       let episodeId2;
       if (srcPaths.length > 0) {
-        const abs = srcPaths.map((p) => join26(opts.workspaceRoot, p));
+        const abs = srcPaths.map((p) => join27(opts.workspaceRoot, p));
         try {
           const r = await runReindexPass(
             `git-reindex:${profile.name} (${abs.length} files)`,
@@ -54148,8 +54492,8 @@ function createWorkspaceEngine(opts) {
         `[errata] git: ${ev.kind} ${ev.newSha.slice(0, 7)} by ${meta3.authorName} \u2014 ${diff.changedPaths.length} file(s), ${diff.renames.length} rename(s)`
       );
     };
-    const gitDir = join26(opts.workspaceRoot, ".git");
-    if (existsSync21(gitDir)) {
+    const gitDir = join27(opts.workspaceRoot, ".git");
+    if (existsSync22(gitDir)) {
       stopGit = startGitSensor(gitDir, (ev) => {
         void handleGitEvent(ev).catch((err2) => {
           console.warn("[errata] git event handler failed:", err2);
@@ -54162,7 +54506,26 @@ function createWorkspaceEngine(opts) {
         if (n > 0) {
           console.log(`[errata] reconcile: re-indexed ${n} stale file(s) on startup`);
         }
-      }).catch((err2) => console.warn("[errata] startup reconcile failed:", err2));
+      }).catch((err2) => console.warn("[errata] startup reconcile failed:", err2)).finally(() => {
+        try {
+          const reap = reapOrphanedFiles(store, opts.workspaceRoot, profile.id);
+          appendPassLedger(paths.configDir, "orphan-reap", 0, {
+            reaped: reap.reaped,
+            symbolsClosed: reap.symbolsClosed
+          });
+          if (reap.skipped) {
+            console.warn(
+              `[errata] orphan reap skipped (${reap.skipped}${reap.candidates !== void 0 ? `, ${reap.candidates} candidates` : ""}) \u2014 no File nodes closed`
+            );
+          } else if (reap.reaped > 0) {
+            console.log(
+              `[errata] orphan reap: closed ${reap.reaped} File node(s) no longer indexed (${reap.symbolsClosed} symbol(s) with them)`
+            );
+          }
+        } catch (err2) {
+          console.warn("[errata] orphan reap failed:", err2 instanceof Error ? err2.message : err2);
+        }
+      });
     });
   }
   const workingFiles = createWorkingFileState();
@@ -54254,15 +54617,19 @@ function createWorkspaceEngine(opts) {
     doneRender?.();
     try {
       const seq = store.currentIngestSeq();
-      recordRenderLedger(store, ledger, seq, Date.now());
+      const stamped = recordRenderLedger(store, ledger, seq, Date.now());
+      appendPassLedger(paths.configDir, "render", 0, {
+        shown: stamped.shown,
+        evicted: stamped.evicted
+      });
     } catch (err2) {
       console.warn("[errata] render ledger failed:", err2.message?.slice(0, 120));
     }
     writeContextFile(opts.workspaceRoot, body2);
-    const target = join26(opts.workspaceRoot, "AGENTS.md");
+    const target = join27(opts.workspaceRoot, "AGENTS.md");
     writeManagedBlock(target, { body: AGENTS_POINTER_BODY, stable: true, force: true });
     if (elicit) {
-      writePrimingHandles(join26(paths.configDir, "priming-handles.json"), [
+      writePrimingHandles(join27(paths.configDir, "priming-handles.json"), [
         ...snapshot.recentProblems.map((r) => r.node),
         // Resolved-band handles: the ✓ problem AND its Solution are citable
         // (a fix tag on an already-resolved problem no-ops idempotently; the
@@ -54484,7 +54851,7 @@ function createWorkspaceEngine(opts) {
       resultSummary: { exitCode: e.exitCode ?? 1, errorTokens: e.errorTokens }
     });
   };
-  const turnCursorPath = join26(paths.configDir, "turn-cursors.json");
+  const turnCursorPath = join27(paths.configDir, "turn-cursors.json");
   const lastTurnUuid = loadTurnCursors(turnCursorPath);
   const turnOffset = loadTurnOffsets(turnCursorPath);
   const sessionLastProblem = /* @__PURE__ */ new Map();
@@ -54507,8 +54874,9 @@ function createWorkspaceEngine(opts) {
     let linked = 0;
     const t = Date.now();
     let processedTurns = 0;
+    const seqAtStart = store.currentIngestSeq();
     const elicit = isEdgeElicitationEnabled();
-    const handleMap = elicit ? readPrimingHandles(join26(paths.configDir, "priming-handles.json")) : {};
+    const handleMap = elicit ? readPrimingHandles(join27(paths.configDir, "priming-handles.json")) : {};
     const wsRoot = (opts.workspaceRoot ?? "").replace(/\\/g, "/");
     const toRel = (abs) => {
       const p = abs.replace(/\\/g, "/");
@@ -55015,6 +55383,16 @@ function createWorkspaceEngine(opts) {
     if (triaged > 0) {
       console.log(`[errata] triage: ${triaged} wrong-door(s) captured from the conversation`);
     }
+    if (processedTurns > 0) {
+      appendPassLedger(paths.configDir, "capture", Date.now() - t, {
+        turns: processedTurns,
+        minted,
+        resolved,
+        triaged,
+        priorEdges,
+        seqAdvanced: store.currentIngestSeq() - seqAtStart
+      });
+    }
   };
   const harvestTurns = async (sessionId, transcriptPath) => {
     const known = turnOffset.get(sessionId);
@@ -55181,7 +55559,7 @@ function createWorkspaceEngine(opts) {
     try {
       const inputs = emitInputsFromManifest(paths.configDir, paths.skillsManifest);
       emitAndProjectSkills(opts.workspaceRoot, inputs);
-      writePrimingHandles(join26(paths.configDir, "priming-handles.json"), skillHandleNodes(inputs));
+      writePrimingHandles(join27(paths.configDir, "priming-handles.json"), skillHandleNodes(inputs));
     } catch (err2) {
       console.warn("[skills] agent-skills projection failed (non-fatal):", err2 instanceof Error ? err2.message : err2);
     }
@@ -55265,6 +55643,26 @@ function createWorkspaceEngine(opts) {
       }
       return report;
     },
+    semanticMaintenance() {
+      const seqBefore = store.currentIngestSeq();
+      const report = runSemanticMaintenance(store);
+      appendPassLedger(paths.configDir, "semantic-maintenance", report.durationMs, {
+        revisitsCleared: report.revisitsCleared,
+        revisitsStanding: report.revisitsStanding,
+        fixCandidatesSettled: report.fixCandidatesSettled,
+        fixCandidatesAnswered: report.fixCandidates.answered,
+        fixCandidatesIgnored: report.fixCandidates.ignored,
+        fixCandidatesUnsubstantiated: report.fixCandidates.unsubstantiated,
+        fixCandidatesStanding: report.fixCandidates.standing,
+        designResolved: report.designResolved,
+        claimsEvaluated: report.claimsEvaluated,
+        seqAdvanced: store.currentIngestSeq() - seqBefore
+      });
+      if (report.revisitsCleared > 0 || report.fixCandidatesSettled > 0 || report.designResolved > 0) {
+        refreshContextNow();
+      }
+      return report;
+    },
     async nightly() {
       const report = (await runNightly()).report;
       const summarizer = opts.intentSummarizer ?? envIntentSummarizer();
@@ -55280,6 +55678,18 @@ function createWorkspaceEngine(opts) {
           console.warn("[errata] symbol summary sweep failed:", err2 instanceof Error ? err2.message : err2);
         }
       }
+      appendPassLedger(paths.configDir, "graph-rescore", report.durationMs, {
+        scoredNodes: report.scoredNodes,
+        landmarks: report.landmarks,
+        communities: report.communities,
+        motifsPromoted: report.motifsPromoted
+      });
+      appendPassLedger(paths.configDir, "semantic-maintenance", report.durationMs, {
+        revisitsCleared: report.revisitsCleared,
+        fixCandidatesSettled: report.fixCandidatesSettled,
+        designResolved: report.designResolved,
+        claimsEvaluated: report.claimsEvaluated
+      });
       return report;
     },
     async embedSettled() {
@@ -55368,7 +55778,7 @@ function createWorkspaceEngine(opts) {
         console.log(
           "[errata] sync skipped \u2014 cloud sync consent is off (enable with `errata consent sync on`)"
         );
-        const pending = existsSync21(paths.outbox) ? readdirSync9(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
+        const pending = existsSync22(paths.outbox) ? readdirSync9(paths.outbox).filter((f) => f.endsWith(".json")).length : 0;
         return { uploaded: 0, failed: 0, remaining: pending };
       }
       try {
@@ -55455,7 +55865,7 @@ async function startDaemon(opts) {
     reviewUrl: () => webUiUrl + "/review"
   });
   const writeLockFile = (url2) => {
-    writeFileSync19(
+    writeFileSync20(
       engine.paths.daemonLock,
       JSON.stringify({ pid: process.pid, webUiUrl: url2, startedAt: Date.now() }),
       "utf8"
@@ -55498,7 +55908,7 @@ async function startDaemon(opts) {
       );
       await engine.stop();
       try {
-        if (existsSync22(engine.paths.daemonLock)) {
+        if (existsSync23(engine.paths.daemonLock)) {
         }
       } catch {
       }
@@ -55515,16 +55925,16 @@ async function listenServer(fetchFn, port) {
 
 // src/registry.ts
 init_paths();
-import { existsSync as existsSync23, readFileSync as readFileSync22, writeFileSync as writeFileSync20 } from "node:fs";
-import { join as join27 } from "node:path";
+import { existsSync as existsSync24, readFileSync as readFileSync23, writeFileSync as writeFileSync21 } from "node:fs";
+import { join as join28 } from "node:path";
 function registryPath() {
-  return process.env["ERRATA_REGISTRY_PATH"] ?? join27(globalDir(), "workspaces.json");
+  return process.env["ERRATA_REGISTRY_PATH"] ?? join28(globalDir(), "workspaces.json");
 }
 function read() {
   const p = registryPath();
-  if (!existsSync23(p)) return { version: 1, workspaces: {} };
+  if (!existsSync24(p)) return { version: 1, workspaces: {} };
   try {
-    const parsed = JSON.parse(readFileSync22(p, "utf8"));
+    const parsed = JSON.parse(readFileSync23(p, "utf8"));
     return { version: 1, workspaces: parsed.workspaces ?? {} };
   } catch {
     return { version: 1, workspaces: {} };
@@ -55532,7 +55942,7 @@ function read() {
 }
 function write(reg) {
   ensureDir(globalDir());
-  writeFileSync20(registryPath(), JSON.stringify(reg, null, 2), "utf8");
+  writeFileSync21(registryPath(), JSON.stringify(reg, null, 2), "utf8");
 }
 function registerWorkspace(profile, root, now = Date.now()) {
   const reg = read();
@@ -55549,7 +55959,7 @@ function pruneMissingWorkspaces() {
   const reg = read();
   const removed = [];
   for (const [id, entry] of Object.entries(reg.workspaces)) {
-    if (!existsSync23(entry.path)) {
+    if (!existsSync24(entry.path)) {
       removed.push(entry);
       delete reg.workspaces[id];
     }
@@ -55558,13 +55968,13 @@ function pruneMissingWorkspaces() {
   return removed;
 }
 function workspaceStatus(entry) {
-  const missing = !existsSync23(entry.path);
+  const missing = !existsSync24(entry.path);
   const lockPath = workspacePaths(entry.path).daemonLock;
   let running = false;
   let webUiUrl = null;
-  if (existsSync23(lockPath)) {
+  if (existsSync24(lockPath)) {
     try {
-      const lock = JSON.parse(readFileSync22(lockPath, "utf8"));
+      const lock = JSON.parse(readFileSync23(lockPath, "utf8"));
       if (lock.pid && lock.webUiUrl && pidAlive(lock.pid)) {
         running = true;
         webUiUrl = lock.webUiUrl;
@@ -55592,7 +56002,7 @@ function pidAlive(pid) {
 // src/multi.ts
 init_dist();
 init_src5();
-import { readFileSync as readFileSync25, unlinkSync as unlinkSync3, writeFileSync as writeFileSync21 } from "node:fs";
+import { readFileSync as readFileSync26, unlinkSync as unlinkSync3, writeFileSync as writeFileSync22 } from "node:fs";
 
 // src/principle-sync.ts
 init_src5();
@@ -55620,8 +56030,8 @@ init_reconcile();
 
 // src/lockfile-auto.ts
 init_src();
-import { existsSync as existsSync24, readFileSync as readFileSync23 } from "node:fs";
-import { join as join28 } from "node:path";
+import { existsSync as existsSync25, readFileSync as readFileSync24 } from "node:fs";
+import { join as join29 } from "node:path";
 
 // src/package-index.ts
 init_src();
@@ -55770,11 +56180,11 @@ function runLockfilePass(opts) {
     { file: "package-lock.json", parse: parsePackageLockJson }
   ];
   for (const c of candidates) {
-    const p = join28(opts.root, c.file);
-    if (!existsSync24(p)) continue;
+    const p = join29(opts.root, c.file);
+    if (!existsSync25(p)) continue;
     let sbom;
     try {
-      sbom = c.parse(readFileSync23(p, "utf8"));
+      sbom = c.parse(readFileSync24(p, "utf8"));
     } catch {
       continue;
     }
@@ -56222,7 +56632,7 @@ var ConsolidateWorker = class {
 init_paths();
 
 // src/lock.ts
-import { existsSync as existsSync25, readFileSync as readFileSync24 } from "node:fs";
+import { existsSync as existsSync26, readFileSync as readFileSync25 } from "node:fs";
 function isProcessAlive(pid) {
   if (!pid || pid <= 0) return false;
   try {
@@ -56233,9 +56643,9 @@ function isProcessAlive(pid) {
   }
 }
 function readDaemonLock(lockPath) {
-  if (!existsSync25(lockPath)) return null;
+  if (!existsSync26(lockPath)) return null;
   try {
-    const lock = JSON.parse(readFileSync24(lockPath, "utf8"));
+    const lock = JSON.parse(readFileSync25(lockPath, "utf8"));
     return typeof lock.pid === "number" ? lock : null;
   } catch {
     return null;
@@ -56519,12 +56929,12 @@ async function reanchorProject(opts) {
 }
 
 // src/adopt.ts
-import { existsSync as existsSync26 } from "node:fs";
-import { dirname as dirname10, join as join29 } from "node:path";
+import { existsSync as existsSync27 } from "node:fs";
+import { dirname as dirname10, join as join30 } from "node:path";
 function findGitRoot(absPath) {
   let dir = absPath;
   for (let depth = 0; depth < 64; depth++) {
-    if (existsSync26(join29(dir, ".git"))) return dir;
+    if (existsSync27(join30(dir, ".git"))) return dir;
     const parent = dirname10(dir);
     if (parent === dir) return null;
     dir = parent;
@@ -56773,7 +57183,7 @@ async function startMultiDaemon(opts = {}) {
     void ambientLinkAll();
     app.route(`/ws/${rec.id}`, rec.webApp);
     try {
-      writeFileSync21(
+      writeFileSync22(
         rec.engine.paths.daemonLock,
         JSON.stringify({ pid: process.pid, webUiUrl: `${baseUrl}/ws/${rec.id}`, startedAt: Date.now() }),
         "utf8"
@@ -56962,7 +57372,7 @@ async function startMultiDaemon(opts = {}) {
   baseUrl = `http://127.0.0.1:${port}`;
   try {
     ensureDir(globalDir());
-    writeFileSync21(
+    writeFileSync22(
       lockPath,
       JSON.stringify({ pid: process.pid, webUiUrl: baseUrl, startedAt: Date.now() }),
       "utf8"
@@ -56971,7 +57381,7 @@ async function startMultiDaemon(opts = {}) {
   }
   for (const r of records) {
     try {
-      writeFileSync21(
+      writeFileSync22(
         r.engine.paths.daemonLock,
         JSON.stringify({ pid: process.pid, webUiUrl: `${baseUrl}/ws/${r.id}`, startedAt: Date.now() }),
         "utf8"
@@ -57098,6 +57508,22 @@ async function startMultiDaemon(opts = {}) {
       }
       return out2;
     },
+    semanticMaintenanceAll() {
+      const out2 = /* @__PURE__ */ new Map();
+      for (const r of records) {
+        const done = markPass(`semantic:${r.entry.name}`);
+        try {
+          out2.set(r.id, r.engine.semanticMaintenance());
+        } catch (err2) {
+          console.warn(
+            `[errata] semantic maintenance failed for ${r.entry.name}: ${err2 instanceof Error ? err2.message : err2}`
+          );
+        } finally {
+          done();
+        }
+      }
+      return out2;
+    },
     async nightlyAll() {
       const out2 = /* @__PURE__ */ new Map();
       for (const r of records) {
@@ -57503,7 +57929,7 @@ async function startMultiDaemon(opts = {}) {
     },
     async stop() {
       try {
-        const cur = readFileSync25(lockPath, "utf8");
+        const cur = readFileSync26(lockPath, "utf8");
         if (JSON.parse(cur).pid === process.pid) unlinkSync3(lockPath);
       } catch {
       }
@@ -58520,21 +58946,21 @@ async function cmdInit() {
   if (!skipHooks) {
     console.log("");
     console.log("installing harness hooks...");
-    const { existsSync: existsSync28 } = await import("node:fs");
-    const { join: join31 } = await import("node:path");
+    const { existsSync: existsSync29 } = await import("node:fs");
+    const { join: join32 } = await import("node:path");
     try {
       await installClaudeHooks(port);
     } catch (err2) {
       console.warn(`  \u26A0\uFE0F  Claude hook install failed: ${err2 instanceof Error ? err2.message : err2}`);
     }
-    if (existsSync28(join31(ROOT, ".cursor"))) {
+    if (existsSync29(join32(ROOT, ".cursor"))) {
       try {
         await installCursorMcpConfig();
       } catch (err2) {
         console.warn(`  \u26A0\uFE0F  Cursor MCP config failed: ${err2 instanceof Error ? err2.message : err2}`);
       }
     }
-    if (existsSync28(join31(ROOT, ".codex"))) {
+    if (existsSync29(join32(ROOT, ".codex"))) {
       try {
         await installCodexHooks(port);
       } catch (err2) {
@@ -58691,9 +59117,9 @@ async function cmdStatus() {
     console.log(`    stack:     ${profile.stack.join(", ") || "(none)"}`);
     console.log(`    languages: ${profile.languages.join(", ") || "(none)"}`);
   }
-  console.log(`  graph db:  ${existsSync27(paths.castalia) ? "yes" : "no"} (${paths.castalia})`);
-  console.log(`  event log: ${existsSync27(paths.eventLog) ? "yes" : "no"} (${paths.eventLog})`);
-  if (existsSync27(paths.castalia)) {
+  console.log(`  graph db:  ${existsSync28(paths.castalia) ? "yes" : "no"} (${paths.castalia})`);
+  console.log(`  event log: ${existsSync28(paths.eventLog) ? "yes" : "no"} (${paths.eventLog})`);
+  if (existsSync28(paths.castalia)) {
     try {
       const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src5(), src_exports2));
       const store = openGraphStore2({ path: paths.castalia });
@@ -59374,11 +59800,11 @@ function cmdInstallationProfile(args2) {
 }
 async function cmdReview() {
   const paths = workspacePaths(ROOT);
-  if (!existsSync27(paths.reviewQueue)) {
+  if (!existsSync28(paths.reviewQueue)) {
     console.log("(review queue empty)");
     return;
   }
-  const queue = JSON.parse(readFileSync26(paths.reviewQueue, "utf8"));
+  const queue = JSON.parse(readFileSync27(paths.reviewQueue, "utf8"));
   if (queue.length === 0) {
     console.log("(review queue empty)");
     return;
@@ -60049,7 +60475,7 @@ async function gatherRepo(store, ws) {
   };
 }
 async function gatherReportData(generatedAt) {
-  const { existsSync: existsSync28 } = await import("node:fs");
+  const { existsSync: existsSync29 } = await import("node:fs");
   const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src5(), src_exports2));
   const cfg = loadConfig();
   const outbound = cfg.consent.sync ? "auto" : "off";
@@ -60057,7 +60483,7 @@ async function gatherReportData(generatedAt) {
   for (const ws of listWorkspaces()) {
     if (ws.missing) continue;
     const dbPath = workspacePaths(ws.path).castalia;
-    if (!existsSync28(dbPath)) continue;
+    if (!existsSync29(dbPath)) continue;
     let store = null;
     try {
       store = openGraphStore2({ path: dbPath });
@@ -60088,7 +60514,7 @@ async function gatherReportData(generatedAt) {
   };
 }
 async function cmdReport(args2) {
-  const { mkdirSync: mkdirSync8, writeFileSync: writeFileSync22 } = await import("node:fs");
+  const { mkdirSync: mkdirSync8, writeFileSync: writeFileSync23 } = await import("node:fs");
   const { renderReport: renderReport2 } = await Promise.resolve().then(() => (init_report_render(), report_render_exports));
   const includeFutureVerbs = args2.includes("--future-verbs");
   const now = /* @__PURE__ */ new Date();
@@ -60101,8 +60527,8 @@ async function cmdReport(args2) {
   const outDir = workspacePaths(ROOT).configDir;
   mkdirSync8(outDir, { recursive: true });
   const files = renderReport2(data, { includeFutureVerbs });
-  for (const f of files) writeFileSync22(join30(outDir, f.name), f.html, "utf8");
-  const indexPath = join30(outDir, "report.html");
+  for (const f of files) writeFileSync23(join31(outDir, f.name), f.html, "utf8");
+  const indexPath = join31(outDir, "report.html");
   console.log(`report \u2192 ${indexPath}`);
   console.log(
     `  ${data.repos.length} repo(s) \xB7 ${files.length} file(s) \xB7 ${data.rollup.nodes.toLocaleString("en-US")} nodes`
@@ -60220,15 +60646,15 @@ function hookRelayCommand(port, path2) {
   return process.platform === "win32" ? `cmd //c "curl -s --connect-timeout 1 --max-time 2 -X POST -H \\"Content-Type: application/json\\" --data-binary @- ${url2} 2>NUL || echo {}"` : `curl -s --connect-timeout 1 --max-time 2 -X POST -H 'Content-Type: application/json' --data-binary @- ${url2} 2>/dev/null || echo '{}'`;
 }
 async function installClaudeHooks(port) {
-  const { mkdirSync: mkdirSync8, existsSync: existsSync28, readFileSync: readFileSync27, writeFileSync: writeFileSync22 } = await import("node:fs");
-  const { join: join31 } = await import("node:path");
-  const dir = join31(ROOT, ".claude");
-  if (!existsSync28(dir)) mkdirSync8(dir, { recursive: true });
-  const file2 = join31(dir, "settings.json");
+  const { mkdirSync: mkdirSync8, existsSync: existsSync29, readFileSync: readFileSync28, writeFileSync: writeFileSync23 } = await import("node:fs");
+  const { join: join32 } = await import("node:path");
+  const dir = join32(ROOT, ".claude");
+  if (!existsSync29(dir)) mkdirSync8(dir, { recursive: true });
+  const file2 = join32(dir, "settings.json");
   let settings = {};
-  if (existsSync28(file2)) {
+  if (existsSync29(file2)) {
     try {
-      settings = JSON.parse(readFileSync27(file2, "utf8"));
+      settings = JSON.parse(readFileSync28(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -60274,10 +60700,10 @@ async function installClaudeHooks(port) {
     dropErrata(list);
     list.push({ hooks: [{ type: "command", command: injectCmd }] });
   }
-  writeFileSync22(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  writeFileSync23(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
   console.log(`installed Claude Code hooks \u2192 ${file2}`);
   await installClaudeMcpConfig();
-  const claudeMd = join31(ROOT, "CLAUDE.md");
+  const claudeMd = join32(ROOT, "CLAUDE.md");
   const recall = writeManagedBlock(claudeMd, { body: RECALL_FIRST_BLOCK });
   if (recall.kind === "collision") {
     console.warn(
@@ -60289,15 +60715,15 @@ async function installClaudeHooks(port) {
   console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
 }
 async function installClaudeMcpConfig() {
-  const { mkdirSync: mkdirSync8, existsSync: existsSync28, readFileSync: readFileSync27, writeFileSync: writeFileSync22 } = await import("node:fs");
-  const { join: join31, dirname: dirname11 } = await import("node:path");
-  const file2 = join31(ROOT, ".mcp.json");
+  const { mkdirSync: mkdirSync8, existsSync: existsSync29, readFileSync: readFileSync28, writeFileSync: writeFileSync23 } = await import("node:fs");
+  const { join: join32, dirname: dirname11 } = await import("node:path");
+  const file2 = join32(ROOT, ".mcp.json");
   const dir = dirname11(file2);
-  if (!existsSync28(dir)) mkdirSync8(dir, { recursive: true });
+  if (!existsSync29(dir)) mkdirSync8(dir, { recursive: true });
   let cfg = {};
-  if (existsSync28(file2)) {
+  if (existsSync29(file2)) {
     try {
-      cfg = JSON.parse(readFileSync27(file2, "utf8"));
+      cfg = JSON.parse(readFileSync28(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -60305,21 +60731,21 @@ async function installClaudeMcpConfig() {
   }
   cfg.mcpServers ??= {};
   cfg.mcpServers["errata"] = errataMcpInvocation();
-  writeFileSync22(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  writeFileSync23(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   console.log(`installed Claude Code MCP server config \u2192 ${file2}`);
   console.log(`  Claude Code will spawn \`errata mcp\` on workspace open.`);
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses / show / similar`);
 }
 async function installCursorMcpConfig() {
-  const { mkdirSync: mkdirSync8, existsSync: existsSync28, readFileSync: readFileSync27, writeFileSync: writeFileSync22 } = await import("node:fs");
-  const { join: join31 } = await import("node:path");
-  const dir = join31(ROOT, ".cursor");
-  if (!existsSync28(dir)) mkdirSync8(dir, { recursive: true });
-  const file2 = join31(dir, "mcp.json");
+  const { mkdirSync: mkdirSync8, existsSync: existsSync29, readFileSync: readFileSync28, writeFileSync: writeFileSync23 } = await import("node:fs");
+  const { join: join32 } = await import("node:path");
+  const dir = join32(ROOT, ".cursor");
+  if (!existsSync29(dir)) mkdirSync8(dir, { recursive: true });
+  const file2 = join32(dir, "mcp.json");
   let cfg = {};
-  if (existsSync28(file2)) {
+  if (existsSync29(file2)) {
     try {
-      cfg = JSON.parse(readFileSync27(file2, "utf8"));
+      cfg = JSON.parse(readFileSync28(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -60327,7 +60753,7 @@ async function installCursorMcpConfig() {
   }
   cfg.mcpServers ??= {};
   cfg.mcpServers["errata"] = errataMcpInvocation();
-  writeFileSync22(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  writeFileSync23(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   console.log(`installed Cursor MCP server config \u2192 ${file2}`);
   console.log(`  Cursor will spawn \`errata mcp\` on workspace open.`);
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses`);
@@ -60335,16 +60761,16 @@ async function installCursorMcpConfig() {
   console.log(`  \u26A0\uFE0F  reload Cursor (Cmd/Ctrl-Shift-P \u2192 "Reload Window") to pick it up.`);
 }
 async function installCodexHooks(port) {
-  const { mkdirSync: mkdirSync8, existsSync: existsSync28, readFileSync: readFileSync27, writeFileSync: writeFileSync22 } = await import("node:fs");
-  const { join: join31 } = await import("node:path");
-  const dir = join31(ROOT, ".codex");
-  if (!existsSync28(dir)) mkdirSync8(dir, { recursive: true });
-  const file2 = join31(dir, "config.toml");
+  const { mkdirSync: mkdirSync8, existsSync: existsSync29, readFileSync: readFileSync28, writeFileSync: writeFileSync23 } = await import("node:fs");
+  const { join: join32 } = await import("node:path");
+  const dir = join32(ROOT, ".codex");
+  if (!existsSync29(dir)) mkdirSync8(dir, { recursive: true });
+  const file2 = join32(dir, "config.toml");
   const BEGIN = `# >>> errata hooks (errata-managed)`;
   const END = `# <<< errata hooks`;
   let existing = "";
-  if (existsSync28(file2)) {
-    existing = readFileSync27(file2, "utf8");
+  if (existsSync29(file2)) {
+    existing = readFileSync28(file2, "utf8");
     const beginIdx = existing.indexOf(BEGIN);
     const endIdx = existing.indexOf(END);
     if (beginIdx >= 0 && endIdx > beginIdx) {
@@ -60373,7 +60799,7 @@ ${END}
   const final = existing.length > 0 && !existing.endsWith("\n") ? `${existing}
 
 ${block}` : existing + (existing.endsWith("\n\n") ? "" : "\n") + block;
-  writeFileSync22(file2, final, "utf8");
+  writeFileSync23(file2, final, "utf8");
   console.log(`installed Codex hooks \u2192 ${file2}`);
   console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
   console.log("");
@@ -60566,16 +60992,38 @@ async function cmdDash(args2) {
     }).catch(() => {
     });
   };
+  const runSemanticPass = (reason) => {
+    try {
+      const reports = handle2.semanticMaintenanceAll();
+      let cleared = 0;
+      let settled = 0;
+      let raised = 0;
+      for (const r of reports.values()) {
+        cleared += r.revisitsCleared;
+        settled += r.fixCandidatesSettled;
+        raised += r.designResolved;
+      }
+      if (cleared > 0 || settled > 0 || raised > 0) {
+        console.log(
+          `[semantic:${reason}] asks settled ${settled}, revisits cleared ${cleared}, questions raised ${raised}`
+        );
+      }
+    } catch (err2) {
+      console.warn(`[semantic] pass failed: ${err2 instanceof Error ? err2.message : err2}`);
+    }
+  };
   const scheduleQuiescenceFlush = () => {
     if (quiesceTimer) clearTimeout(quiesceTimer);
     quiesceTimer = setTimeout(() => {
       quiesceTimer = null;
       runBoundaryFlush("quiescent");
+      runSemanticPass("quiescent");
       triggerConsolidation(false);
     }, QUIESCENCE_MS);
   };
   handle2.onSessionBoundary(() => {
     runBoundaryFlush("session-end");
+    runSemanticPass("session-end");
     triggerConsolidation(true);
   });
   let ticking = false;
@@ -60687,7 +61135,7 @@ async function cmdDash(args2) {
       await yieldToLoop2();
       try {
         const items = selectDurableMemory(handle2.sharedStore, r.engine.profile);
-        const res = bleedRules(join30(r.root, ".claude", "rules"), items);
+        const res = bleedRules(join31(r.root, ".claude", "rules"), items);
         if (res.written || res.pruned) {
           console.log(
             `[rules:${r.entry.name}] ${res.written} collective principle(s) \u2192 .claude/rules` + (res.pruned ? `, ${res.pruned} pruned` : "")
@@ -60789,7 +61237,10 @@ async function cmdDash(args2) {
     }
   };
   triggerConsolidation = (force) => void maybeConsolidate(force);
-  const nightlyInterval = setInterval(() => triggerConsolidation(false), NIGHTLY_INTERVAL_MS);
+  const nightlyInterval = setInterval(() => {
+    runSemanticPass("periodic");
+    triggerConsolidation(false);
+  }, NIGHTLY_INTERVAL_MS);
   const shutdown = async (signal) => {
     console.log(`
 shutting down\u2026 (${signal})`);