@inerrata-corporation/errata 2.0.2-dev.982 → 2.0.2

package/errata.mjs

@@ -64,7 +64,7 @@ function toCloudAttrs(attrs) {
   }
   return rest2;
 }
-var SEMANTIC_NODE_LABELS, CONTEXT_NODE_LABELS, CODE_NODE_LABELS, ALL_NODE_LABELS, STRUCTURAL_EDGES, CAUSAL_EDGES, RESOLUTION_EDGES, CONCEPTUAL_EDGES, EVIDENCE_EDGES, CODE_EDGES, BRIDGE_EDGES, IDENTITY_EDGES, JUSTIFICATION_EDGES, BELIEF_EDGES, ABSTRACTION_EDGES, DECOMPOSITION_EDGES, TRANSFER_EDGES, SOLUTION_STRUCTURE_EDGES, SUSPICION_EDGES, TAXONOMY_EDGES, TRIAGE_EDGES, GIT_EDGES, ALL_EDGE_TYPES, PAGERANK_EXCLUSIONS, EDGE_WEIGHT, EDGE_CONDUCTANCE_OVERRIDES, CAUSAL_PROTECT_EDGES, VALIDATION_SOURCES, TRUTH_KIND, ABSTRACTION_LEVEL, PROBLEM_RESOLUTION, DRIFT_KIND, TEST_PATH_RE, TEST_SCOPE_RE;
+var SEMANTIC_NODE_LABELS, ANCHOR_REFUSAL_REASONS, ROUTING_REASONS, CONTEXT_NODE_LABELS, CODE_NODE_LABELS, ALL_NODE_LABELS, STRUCTURAL_EDGES, CAUSAL_EDGES, RESOLUTION_EDGES, CONCEPTUAL_EDGES, EVIDENCE_EDGES, CODE_EDGES, BRIDGE_EDGES, IDENTITY_EDGES, JUSTIFICATION_EDGES, BELIEF_EDGES, ABSTRACTION_EDGES, DECOMPOSITION_EDGES, TRANSFER_EDGES, SOLUTION_STRUCTURE_EDGES, SUSPICION_EDGES, TAXONOMY_EDGES, TRIAGE_EDGES, GIT_EDGES, ALL_EDGE_TYPES, PAGERANK_EXCLUSIONS, EDGE_WEIGHT, EDGE_CONDUCTANCE_OVERRIDES, CAUSAL_PROTECT_EDGES, VALIDATION_SOURCES, TRUTH_KIND, ABSTRACTION_LEVEL, PROBLEM_RESOLUTION, DRIFT_KIND, TEST_PATH_RE, TEST_SCOPE_RE;
 var init_castalia = __esm({
   "../../packages/shared/src/castalia.ts"() {
     "use strict";
@@ -96,6 +96,43 @@ var init_castalia = __esm({
       // truth (PLAN_PLASTICITY §2.3 / §4). truthKind/scope/groundedSupport in attrs.
       "Claim"
     ];
+    ANCHOR_REFUSAL_REASONS = [
+      /** The spine probe ran CLEAN and did not confirm the public claim. */
+      "spine-refused",
+      /** No anchor tag at all — cannot positively confirm, fail closed. */
+      "untagged-failclosed",
+      /** The daemon itself tagged the anchor private — a deliberate claim, not a refusal. */
+      "daemon-tagged-private",
+      /** The probe threw or timed out — the system was blind, not decided (see routingProbeFailed). */
+      "probe-failed"
+    ];
+    ROUTING_REASONS = [
+      /** Harness org (CTF lane, e2e battery, canary) — forced org-private. */
+      "harness-clamp",
+      /** A signed gateway write target named the destination. */
+      "signed-target-public",
+      "signed-target-org",
+      "signed-target-team",
+      /** No membrane in play (gate off, or a caller with no org) — collective. */
+      "membrane-off",
+      /** A public Domain/Algorithm of this name already exists — recognized topic. */
+      "label-public-exists",
+      /** A Domain/Algorithm naming no existing public topic — fails closed. */
+      "label-novel-failclosed",
+      /** The spine confirmed the anchor and no promotion gate stood in the way. */
+      "spine-public",
+      /** Spine-confirmed, but the rule-of-3 gate held it back for later graduation. */
+      "promotion-gate-denied",
+      /** The spine did not confirm a public anchor. `routingProbeFailed` says
+       *  whether that was a verdict or a blind spot. */
+      "spine-private"
+      // NOTE: no `report-*` reason. Report-extracted nodes (D2) go through the same
+      // `routeOrgVisibility` decision as every other write, with the row's stored
+      // scope as the enforced target, so they carry `signed-target-*` /
+      // `harness-clamp` like anything else. The first D2 router (!1526) minted a
+      // `report-scope-inherited` reason from a scope field-copy; it was retired
+      // 2026-08-15 with zero nodes carrying it (dev count 0; prod extraction off).
+    ];
     CONTEXT_NODE_LABELS = [
       "Language",
       "Package",
@@ -251,7 +288,7 @@ var init_castalia = __esm({
     DECOMPOSITION_EDGES = ["SPLIT_INTO"];
     TRANSFER_EDGES = ["MAY_RESOLVE"];
     SOLUTION_STRUCTURE_EDGES = ["BUILDS_ON", "SUPERSEDES", "ALTERNATIVE_TO"];
-    SUSPICION_EDGES = ["SUSPECTED_LINK"];
+    SUSPICION_EDGES = ["SUSPECTED_LINK", "REGRESSION_OF"];
     TAXONOMY_EDGES = ["IS_A"];
     TRIAGE_EDGES = ["TRIAGED_BY", "CONFIRMS", "INDICATES", "ROUTES_TO"];
     GIT_EDGES = ["POINTS_AT", "PARENT", "AUTHORED_BY"];
@@ -316,8 +353,10 @@ var init_castalia = __esm({
       "ALTERNATIVE_TO",
       // symmetric peer marker — weight would let alternatives inflate each other
       // NB: BUILDS_ON is NOT excluded — it flows extension→base so foundational solutions rank up.
-      "SUSPECTED_LINK"
+      "SUSPECTED_LINK",
       // Somnus hypothesis (PLAN_SOMNUS_V2 §4) — never flows rank; navigation-invisible.
+      "REGRESSION_OF"
+      // recurrence marker (RG-recognize) — a question about a close, not signal-flow.
     ]);
     EDGE_WEIGHT = {
       // Causal — high signal
@@ -430,6 +469,7 @@ var init_castalia = __esm({
       ALTERNATIVE_TO: 0,
       // Suspicion — a hypothesis, weightless + PageRank-excluded (never flows rank / EIG).
       SUSPECTED_LINK: 0,
+      REGRESSION_OF: 0,
       // Git — topology/authorship, weightless (not domain signal-flow)
       POINTS_AT: 0,
       PARENT: 0,
@@ -472,6 +512,76 @@ var init_castalia = __esm({
   }
 });
 
+// ../../packages/shared/src/graph-events.ts
+function unregisteredGraphEventKeys(event, attrKeys) {
+  const vocab = GRAPH_EVENT_VOCABULARIES[event];
+  if (!vocab) return [`<unregistered event: ${event}>`];
+  const exact = new Set(vocab.keys ?? []);
+  const offenders = [];
+  for (const key of attrKeys) {
+    if (exact.has(key)) continue;
+    if (vocab.prefixes.some((prefix) => key.startsWith(prefix))) continue;
+    offenders.push(key);
+  }
+  return offenders;
+}
+function assertGraphEventVocabulary(event, attrs) {
+  const env2 = typeof process !== "undefined" ? process.env["NODE_ENV"] : void 0;
+  if (env2 === "production") return;
+  const offenders = unregisteredGraphEventKeys(event, Object.keys(attrs));
+  if (offenders.length === 0) return;
+  const message = `graph event '${event}' emits unregistered attribute key(s): ${offenders.join(", ")} \u2014 register the vocabulary and its obligated consumer in @inerrata-corporation/shared graph-events.ts (contribution contract D17)`;
+  console.error(message);
+  throw new UnregisteredGraphEventError(message);
+}
+var GRAPH_EVENT_VOCABULARIES, UnregisteredGraphEventError;
+var init_graph_events = __esm({
+  "../../packages/shared/src/graph-events.ts"() {
+    "use strict";
+    GRAPH_EVENT_VOCABULARIES = {
+      "graph.ingest": {
+        // 'queue.' and 'skew.' (queue-health.ts, process-cumulative levels) were
+        // found by this registry's FIRST enforcement run to have no consumer
+        // anywhere in the tree — registered with that fact stated rather than
+        // silently admitted, so the next graph-health pass either gives them a
+        // trigger or retires them (D12: a record nothing reads is the defect).
+        prefixes: ["ingest.", "sanitize.", "queue.", "skew."],
+        consumer: "graph-health.mjs ingest triggers (edge-reject RATE, reinforcedFraction band, the volume floor) + the 'Graph \u2014 Ingest funnel & integrity' board. queue.*/skew.* currently have NO standing consumer (found unread 2026-08-14) \u2014 trigger or retirement owed"
+      },
+      "graph.twin": {
+        prefixes: [],
+        keys: ["rewritten", "already-generic", "rejected", "failed", "low-content", "threw", "failureFraction"],
+        consumer: "failureFraction is the alertable number (twin-outcomes.ts); its graph-health.mjs trigger is pending a live baseline"
+      },
+      "graph.burst": {
+        prefixes: ["burst."],
+        consumer: "the 'Graph \u2014 Demand loop (voids & hypotheses)' board \u2014 misses always emitted, hits sampled 1-in-10"
+      },
+      "graph.promotion": {
+        prefixes: ["promotion."],
+        consumer: "graph-health.mjs promotion triggers (receipt-absence floor, kCountErrors > 0) + probe:mechanism-liveness reading the durable pgboss.job.output twin"
+      },
+      "graph.census": {
+        prefixes: [
+          "nodes.",
+          "tier.",
+          "edges.",
+          "suspectedLinks.",
+          "voids.",
+          "membrane.",
+          "prose.",
+          "overlay."
+        ],
+        keys: ["communities", "landmarks", "ingestSeq", "censusPgErrored"],
+        consumer: "graph-health.mjs census triggers (reversedResolution, communities floor, byVisibility.other drift) + the 'Graph \u2014 Metabolism (nightly pipeline)' board"
+      }
+    };
+    UnregisteredGraphEventError = class extends Error {
+      name = "UnregisteredGraphEventError";
+    };
+  }
+});
+
 // ../../packages/shared/src/canonical/hash.ts
 import { createHash } from "node:crypto";
 function sha256(input) {
@@ -15979,6 +16089,7 @@ __export(src_exports, {
   ALL_EDGE_TYPES: () => ALL_EDGE_TYPES,
   ALL_NODE_LABELS: () => ALL_NODE_LABELS,
   AMBIGUOUS_ALIASES: () => AMBIGUOUS_ALIASES,
+  ANCHOR_REFUSAL_REASONS: () => ANCHOR_REFUSAL_REASONS,
   BELIEF_EDGES: () => BELIEF_EDGES,
   BRIDGE_EDGES: () => BRIDGE_EDGES,
   CAUSAL_EDGES: () => CAUSAL_EDGES,
@@ -16000,6 +16111,7 @@ __export(src_exports, {
   EDGE_WEIGHT: () => EDGE_WEIGHT,
   EVIDENCE_EDGES: () => EVIDENCE_EDGES,
   GIT_EDGES: () => GIT_EDGES,
+  GRAPH_EVENT_VOCABULARIES: () => GRAPH_EVENT_VOCABULARIES,
   IDENTITY_EDGES: () => IDENTITY_EDGES,
   INGEST_EXTRACTION_SOURCES: () => INGEST_EXTRACTION_SOURCES,
   INGEST_SOURCES: () => INGEST_SOURCES,
@@ -16016,6 +16128,7 @@ __export(src_exports, {
   QUARANTINE_EXTRACTION_SOURCE_PREFIX: () => QUARANTINE_EXTRACTION_SOURCE_PREFIX,
   RESOLUTION_EDGES: () => RESOLUTION_EDGES,
   RE_LEADING_ARTICLE: () => RE_LEADING_ARTICLE,
+  ROUTING_REASONS: () => ROUTING_REASONS,
   RouteContextCountWireSchema: () => RouteContextCountWireSchema,
   SEMANTIC_NODE_LABELS: () => SEMANTIC_NODE_LABELS,
   SOLUTION_STRUCTURE_EDGES: () => SOLUTION_STRUCTURE_EDGES,
@@ -16027,9 +16140,11 @@ __export(src_exports, {
   TRANSFER_EDGES: () => TRANSFER_EDGES,
   TRIAGE_EDGES: () => TRIAGE_EDGES,
   TRUTH_KIND: () => TRUTH_KIND,
+  UnregisteredGraphEventError: () => UnregisteredGraphEventError,
   VALIDATION_SOURCES: () => VALIDATION_SOURCES,
   aliasesLongestFirst: () => aliasesLongestFirst,
   allEntities: () => allEntities,
+  assertGraphEventVocabulary: () => assertGraphEventVocabulary,
   canonicalClaimId: () => canonicalClaimId,
   canonicalJSON: () => canonicalJSON,
   canonicalize: () => canonicalize,
@@ -16091,6 +16206,7 @@ __export(src_exports, {
   summaryRejectionReason: () => summaryRejectionReason,
   toCloudAttrs: () => toCloudAttrs,
   toolCanonicalId: () => toolCanonicalId,
+  unregisteredGraphEventKeys: () => unregisteredGraphEventKeys,
   validateCastaliaPayload: () => validateCastaliaPayload,
   versionlessPurl: () => versionlessPurl,
   vetSidecarSummaries: () => vetSidecarSummaries
@@ -16099,6 +16215,7 @@ var init_src = __esm({
   "../../packages/shared/src/index.ts"() {
     "use strict";
     init_castalia();
+    init_graph_events();
     init_identity();
     init_wire();
     init_edge_rules();
@@ -16617,7 +16734,13 @@ var init_store = __esm({
       // 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"] }
+      FIXED_BY: { from: EDGE_RULES["FIXED_BY"]?.from, to: ["Solution", "Episode"] },
+      // RG-recognize: a NEW open Problem re-observing a RESOLVED one ("this is
+      // back — the fix didn't hold"). Local-only for now: the instance drain's
+      // INSTANCE_EDGES allowlist doesn't ship it, and the cloud door's matrix
+      // doesn't know it — crossing the membrane is a deliberate later step, never
+      // a side effect (the half-shipped-edge-type lesson).
+      REGRESSION_OF: { from: ["Problem"], to: ["Problem"] }
     };
     SCHEMA_VERSION = 6;
     SCHEMA_SQL = `
@@ -18850,11 +18973,16 @@ function foldDuplicateProblem(store, dup, survivor, ts) {
   if (!surv) return;
   const sources = new Set(surv.attrs["sources"] ?? []);
   for (const s of dup.attrs["sources"] ?? []) sources.add(s);
+  const dupSeq = dup.attrs["createdAtSeq"] ?? store.currentIngestSeq();
+  const exposure = priorExposure(store, survivor.id, dupSeq);
+  const expField = `reinforce${exposure[0].toUpperCase()}${exposure.slice(1)}Count`;
   store.updateNode(survivor.id, {
     attrs: {
       ...surv.attrs,
       sources: [...sources],
-      corroborations: corroborations(surv) + corroborations(dup) + 1
+      corroborations: corroborations(surv) + corroborations(dup) + 1,
+      [expField]: (surv.attrs[expField] ?? 0) + 1,
+      lastReinforceExposure: exposure
     },
     cumulativeHits: (surv.cumulativeHits ?? 0) + (dup.cumulativeHits ?? 0),
     lastUpdatedAt: ts
@@ -19018,7 +19146,22 @@ function ingestDesignProblem(store, flag, opts) {
   const existing = store.getNode(problemId);
   let created = false;
   let corroborated = false;
+  let recurredResolved = false;
+  let reopenedFromRegression = false;
   if (existing) {
+    const resolvedUnretracted = existing.attrs["resolvedAt"] != null && existing.attrs["resolvedAs"] == null;
+    const recurAttrs = () => {
+      recurredResolved = true;
+      const sources2 = existing.attrs["recurrenceSources"] ?? [];
+      return {
+        resolutionSuspect: true,
+        recurredAt: opts.ts,
+        recurrences: (Number(existing.attrs["recurrences"]) || 0) + 1,
+        // RG-reopen: the door touch carries its session — the reopen check
+        // after the update counts DISTINCT sources against REOPEN_MIN_SOURCES.
+        ...sources2.includes(opts.source) ? {} : { recurrenceSources: [...sources2, opts.source].slice(-8) }
+      };
+    };
     const sources = existing.attrs["sources"] ?? [];
     if (!sources.includes(opts.source)) {
       corroborated = true;
@@ -19027,6 +19170,9 @@ function ingestDesignProblem(store, flag, opts) {
       store.updateNode(problemId, {
         attrs: {
           ...existing.attrs,
+          // An INDEPENDENT source re-deriving a resolved problem marks
+          // immediately — that is the strongest recurrence evidence there is.
+          ...resolvedUnretracted ? recurAttrs() : {},
           sources: [...sources, opts.source],
           corroborations: corroborations2,
           ...promoted ? { provisional: false } : {},
@@ -19052,6 +19198,13 @@ function ingestDesignProblem(store, flag, opts) {
         ...reinforcedSeqAttrs(store, existing.label),
         lastUpdatedAt: opts.ts
       });
+      if (recurredResolved) reopenedFromRegression = maybeReopenFromRegression(store, problemId, opts.ts);
+    } else if (resolvedUnretracted && opts.ts - (Number(existing.attrs["recurredAt"]) || 0) > RECURRENCE_DEBOUNCE_MS) {
+      store.updateNode(problemId, {
+        attrs: { ...existing.attrs, ...recurAttrs() },
+        lastUpdatedAt: opts.ts
+      });
+      reopenedFromRegression = maybeReopenFromRegression(store, problemId, opts.ts);
     }
   } else {
     created = true;
@@ -19063,7 +19216,8 @@ function ingestDesignProblem(store, flag, opts) {
         designProblemId: problemId,
         sources: [opts.source],
         corroborations: 0,
-        scope: {}
+        scope: {},
+        ...opts.hostHarness ? { hostHarness: opts.hostHarness } : {}
       })
     );
   }
@@ -19106,7 +19260,17 @@ function ingestDesignProblem(store, flag, opts) {
   const linkText = flag.cause?.trim() ? `${statement} 
  ${flag.cause.trim()}` : statement;
   const linkedPackages = linkProblemToPackages(store, problemId, linkText, opts.ts).linked;
-  return { problemId, created, corroborated, rootCauseId, solutionId, anchored, linkedPackages };
+  return {
+    problemId,
+    created,
+    corroborated,
+    rootCauseId,
+    solutionId,
+    anchored,
+    linkedPackages,
+    ...recurredResolved ? { recurredResolved } : {},
+    ...reopenedFromRegression ? { reopenedFromRegression } : {}
+  };
 }
 function canonicalizePatternText(name2) {
   const stripped = name2.replace(/^\s*pattern(?:\s*[×x]\s*\d+)?\s*(?:\(exemplar\))?\s*[:—–-]\s*/i, "").replace(/\s+/g, " ").trim();
@@ -19252,22 +19416,61 @@ function tokenJaccard(a, b) {
   return inter / (sa.size + sb.size - inter);
 }
 function reinforceSameAnchorProblem(store, relPath, workspaceId2, statement, source, ts, kind = "problem") {
+  return foldSameAnchorProblem(store, relPath, workspaceId2, statement, source, ts, kind).foldedId;
+}
+function foldSameAnchorProblem(store, relPath, workspaceId2, statement, source, ts, kind = "problem") {
+  const report = { ...EMPTY_FOLD_REPORT };
   const stmt = statement.trim();
-  if (!isAnchorableCodePath(relPath)) return null;
+  if (!isAnchorableCodePath(relPath)) {
+    report.noFile = true;
+    return report;
+  }
   const file2 = resolveFileNode(store, relPath, workspaceId2);
-  if (!file2) return null;
+  if (!file2) {
+    report.noFile = true;
+    return report;
+  }
   const selfId = identityId({ kind: "DesignProblem", statement: stmt });
+  let stmtVec = null;
   let best = null;
+  let bestScout = null;
   for (const e of store.inEdges(file2.id, ["ANCHORED_AT"])) {
     const cand = store.getNode(e.from);
     if (!cand || cand.label !== "Problem" || cand.attrs["resolvedAt"]) continue;
     if (cand.id === selfId) continue;
     const candKind = cand.attrs["kind"] === "constraint" ? "constraint" : "problem";
-    if (candKind !== (kind === "constraint" ? "constraint" : "problem")) continue;
+    if (candKind !== (kind === "constraint" ? "constraint" : "problem")) {
+      report.kindVetoed++;
+      continue;
+    }
+    report.candidates++;
     const score2 = tokenJaccard(stmt, cand.description);
+    if (score2 > report.bestJaccard) report.bestJaccard = score2;
     if (score2 >= SAME_ANCHOR_DEDUP_JACCARD && (!best || score2 > best.score)) best = { node: cand, score: score2 };
+    if (!best) {
+      stmtVec ??= embed(stmt);
+      const hc = cosine(stmtVec, embed(cand.description));
+      if (hc > report.bestHashCos) report.bestHashCos = hc;
+      if ((hc >= SAME_ANCHOR_SCOUT_MIN_COSINE || score2 >= SAME_ANCHOR_NOMINATE_JACCARD) && (!bestScout || hc > bestScout.hashCos)) {
+        bestScout = { node: cand, hashCos: hc, jaccard: score2 };
+      }
+    }
   }
-  if (!best) return null;
+  if (!best && bestScout && bestScout.hashCos >= SAME_ANCHOR_SCOUT_AUTO_COSINE) {
+    best = { node: bestScout.node, score: bestScout.jaccard };
+    report.foldedBy = "scout";
+  }
+  if (!best) {
+    if (bestScout) {
+      report.nominate = {
+        targetId: bestScout.node.id,
+        jaccard: bestScout.jaccard,
+        hashCos: bestScout.hashCos
+      };
+    }
+    return report;
+  }
+  report.foldedBy ??= "jaccard";
   const existing = best.node;
   const sources = existing.attrs["sources"] ?? [];
   if (!sources.includes(source)) {
@@ -19289,7 +19492,79 @@ function reinforceSameAnchorProblem(store, relPath, workspaceId2, statement, sou
       lastUpdatedAt: ts
     });
   }
-  return existing.id;
+  report.foldedId = existing.id;
+  return report;
+}
+function findResolvedAnchorMatch(store, relPath, workspaceId2, statement, kind = "problem") {
+  const stmt = statement.trim();
+  if (!isAnchorableCodePath(relPath)) return null;
+  const file2 = resolveFileNode(store, relPath, workspaceId2);
+  if (!file2) return null;
+  const selfId = identityId({ kind: "DesignProblem", statement: stmt });
+  let best = null;
+  for (const e of store.inEdges(file2.id, ["ANCHORED_AT"])) {
+    const cand = store.getNode(e.from);
+    if (!cand || cand.label !== "Problem") continue;
+    if (cand.attrs["resolvedAt"] == null || cand.attrs["resolvedAs"] != null) continue;
+    if (cand.attrs["mergedInto"] !== void 0) continue;
+    if (cand.id === selfId) continue;
+    const candKind = cand.attrs["kind"] === "constraint" ? "constraint" : "problem";
+    if (candKind !== (kind === "constraint" ? "constraint" : "problem")) continue;
+    const score2 = tokenJaccard(stmt, cand.description);
+    if (score2 >= SAME_ANCHOR_DEDUP_JACCARD && (!best || score2 > best.score)) {
+      best = { id: cand.id, score: score2 };
+    }
+  }
+  return best?.id ?? null;
+}
+function maybeReopenFromRegression(store, nodeId, ts) {
+  const n = store.getNode(nodeId);
+  if (!n) return false;
+  if (n.attrs["resolvedAt"] == null || n.attrs["resolvedAs"] != null) return false;
+  const sources = n.attrs["recurrenceSources"] ?? [];
+  if (new Set(sources).size < REOPEN_MIN_SOURCES) return false;
+  const attrs = { ...n.attrs };
+  delete attrs["resolvedAt"];
+  delete attrs["resolutionSuspect"];
+  attrs["reopenedFrom"] = "regression";
+  attrs["reopenedAt"] = ts;
+  store.updateNode(nodeId, { attrs, lastUpdatedAt: ts });
+  return true;
+}
+function markResolvedRecurrence(store, nodeId, ts, source) {
+  const n = store.getNode(nodeId);
+  if (!n) return { marked: false, reopened: false };
+  if (n.attrs["resolvedAt"] == null || n.attrs["resolvedAs"] != null) {
+    return { marked: false, reopened: false };
+  }
+  const sources = n.attrs["recurrenceSources"] ?? [];
+  store.updateNode(nodeId, {
+    attrs: {
+      ...n.attrs,
+      resolutionSuspect: true,
+      recurredAt: ts,
+      recurrences: (Number(n.attrs["recurrences"]) || 0) + 1,
+      ...source && !sources.includes(source) ? { recurrenceSources: [...sources, source].slice(-RECURRENCE_SOURCES_CAP) } : {}
+    },
+    lastUpdatedAt: ts
+  });
+  const reopened = source ? maybeReopenFromRegression(store, nodeId, ts) : false;
+  return { marked: true, reopened };
+}
+function confirmFixHeld(store, solutionId, ts) {
+  let acknowledged = 0;
+  for (const e of store.inEdges(solutionId, ["SOLVED_BY", "FIXED_BY"])) {
+    const p = store.getNode(e.from);
+    if (!p || p.label !== "Problem") continue;
+    if (p.attrs["resolutionSuspect"] !== true || p.attrs["resolvedAt"] == null) continue;
+    const attrs = { ...p.attrs };
+    delete attrs["resolutionSuspect"];
+    attrs["fixHeldConfirmedAt"] = ts;
+    delete attrs["recurrenceSources"];
+    store.updateNode(p.id, { attrs, lastUpdatedAt: ts });
+    acknowledged++;
+  }
+  return acknowledged;
 }
 function isFragmentFixNote(note) {
   const t = note.trim();
@@ -19692,7 +19967,7 @@ function priorExposure(store, nodeId, atSeq) {
   if ((n.attrs["evictedCount"] ?? 0) > 0) return "evicted";
   return "unshown";
 }
-var DESIGN_PROMOTE_AT, STATEMENT_ALIAS_CAP, PATTERN_DEDUP_COSINE, PATTERN_ALIAS_CAP, DEDUP_STOPWORDS, SAME_ANCHOR_DEDUP_JACCARD, CITABLE_PRIOR_LABELS, MAX_ANCHOR_FILES, AUTO_MINT_PREFIX, FIX_CANDIDATE_ASK_LIMIT;
+var DESIGN_PROMOTE_AT, STATEMENT_ALIAS_CAP, RECURRENCE_DEBOUNCE_MS, PATTERN_DEDUP_COSINE, PATTERN_ALIAS_CAP, DEDUP_STOPWORDS, SAME_ANCHOR_DEDUP_JACCARD, EMPTY_FOLD_REPORT, SAME_ANCHOR_SCOUT_AUTO_COSINE, SAME_ANCHOR_SCOUT_MIN_COSINE, SAME_ANCHOR_NOMINATE_JACCARD, REOPEN_MIN_SOURCES, RECURRENCE_SOURCES_CAP, CITABLE_PRIOR_LABELS, MAX_ANCHOR_FILES, AUTO_MINT_PREFIX, FIX_CANDIDATE_ASK_LIMIT;
 var init_design_problem = __esm({
   "../../packages/local-graph/src/design-problem.ts"() {
     "use strict";
@@ -19705,6 +19980,7 @@ var init_design_problem = __esm({
     init_problem_dedup();
     DESIGN_PROMOTE_AT = 1;
     STATEMENT_ALIAS_CAP = 5;
+    RECURRENCE_DEBOUNCE_MS = 60 * 60 * 1e3;
     PATTERN_DEDUP_COSINE = 0.85;
     PATTERN_ALIAS_CAP = 5;
     DEDUP_STOPWORDS = /* @__PURE__ */ new Set([
@@ -19731,6 +20007,21 @@ var init_design_problem = __esm({
       "where"
     ]);
     SAME_ANCHOR_DEDUP_JACCARD = 0.6;
+    EMPTY_FOLD_REPORT = {
+      foldedId: null,
+      foldedBy: null,
+      noFile: false,
+      candidates: 0,
+      kindVetoed: 0,
+      bestJaccard: 0,
+      bestHashCos: 0,
+      nominate: null
+    };
+    SAME_ANCHOR_SCOUT_AUTO_COSINE = 0.85;
+    SAME_ANCHOR_SCOUT_MIN_COSINE = 0.5;
+    SAME_ANCHOR_NOMINATE_JACCARD = 0.3;
+    REOPEN_MIN_SOURCES = 2;
+    RECURRENCE_SOURCES_CAP = 8;
     CITABLE_PRIOR_LABELS = /* @__PURE__ */ new Set([
       "Solution",
       "RootCause",
@@ -21973,6 +22264,160 @@ var init_community2 = __esm({
   }
 });
 
+// ../../packages/local-graph/src/fold-candidates.ts
+function markFoldCandidate(store, problemId, targetId, info2) {
+  if (problemId === targetId) return false;
+  const n = store.getNode(problemId);
+  if (!openProblem(n)) return false;
+  if (n.attrs["foldCandidate"] !== void 0) return false;
+  const rejected = n.attrs["foldRejected"] ?? [];
+  if (rejected.includes(targetId)) return false;
+  if (!openProblem(store.getNode(targetId))) return false;
+  const mark = {
+    targetId,
+    ...info2.hashCos !== void 0 ? { hashCos: info2.hashCos } : {},
+    ...info2.jaccard !== void 0 ? { jaccard: info2.jaccard } : {},
+    source: info2.source,
+    ts: info2.ts,
+    markedAtSeq: store.currentIngestSeq()
+  };
+  store.updateNode(problemId, { attrs: { ...n.attrs, foldCandidate: mark }, lastUpdatedAt: info2.ts });
+  return true;
+}
+function findWorkspaceFoldCandidate(store, workspaceId2, statement, kind, opts) {
+  const stmtVec = embed(statement);
+  const wantConstraint = kind === "constraint";
+  const open2 = store.findNodesByLabel("Problem").filter(
+    (p) => p.attrs["resolvedAt"] == null && p.attrs["mergedInto"] === void 0 && p.id !== opts?.excludeId && (p.attrs["workspaceId"] === void 0 || p.attrs["workspaceId"] === workspaceId2) && isConstraintProblem(p) === wantConstraint
+  ).sort((a, b) => (b.lastUpdatedAt ?? b.createdAt) - (a.lastUpdatedAt ?? a.createdAt)).slice(0, opts?.scanCap ?? WORKSPACE_SCAN_CAP);
+  let best = null;
+  for (const p of open2) {
+    const c = cosine(stmtVec, embed(p.description));
+    if (c >= FOLD_SCOUT_MIN_COSINE && (!best || c > best.hashCos)) best = { targetId: p.id, hashCos: c };
+  }
+  return best;
+}
+function followMerges(store, id) {
+  let cur = store.getNode(id);
+  for (let hop = 0; hop < 3 && cur && cur.attrs["mergedInto"] !== void 0; hop++) {
+    cur = store.getNode(String(cur.attrs["mergedInto"]));
+  }
+  return cur ?? null;
+}
+function clearCandidate(store, node2, ts, rejectTargetId) {
+  const attrs = { ...node2.attrs };
+  delete attrs["foldCandidate"];
+  if (rejectTargetId) {
+    const rejected = attrs["foldRejected"] ?? [];
+    if (!rejected.includes(rejectTargetId)) {
+      attrs["foldRejected"] = [...rejected, rejectTargetId].slice(-FOLD_REJECTED_CAP);
+    }
+  }
+  store.updateNode(node2.id, { attrs, lastUpdatedAt: ts });
+}
+async function resolveFoldCandidates(store, opts) {
+  const report = {
+    examined: 0,
+    folded: 0,
+    foldedEmbedding: 0,
+    foldedJudge: 0,
+    rejected: 0,
+    standing: 0,
+    judgeErrors: 0,
+    retargeted: 0
+  };
+  const limit = opts.limit ?? 8;
+  const marked = store.findNodesByLabel("Problem").filter((p) => openProblem(p) && p.attrs["foldCandidate"] !== void 0).sort((a, b) => {
+    const ma = a.attrs["foldCandidate"].ts ?? 0;
+    const mb = b.attrs["foldCandidate"].ts ?? 0;
+    return ma - mb;
+  }).slice(0, limit);
+  for (const node2 of marked) {
+    const fresh = store.getNode(node2.id);
+    if (!openProblem(fresh)) continue;
+    report.examined++;
+    const mark = fresh.attrs["foldCandidate"];
+    let target = followMerges(store, mark.targetId);
+    if (target && target.id !== mark.targetId) report.retargeted++;
+    if (!openProblem(target)) {
+      clearCandidate(store, fresh, opts.ts);
+      report.rejected++;
+      continue;
+    }
+    if (isConstraintProblem(fresh) !== isConstraintProblem(target)) {
+      clearCandidate(store, fresh, opts.ts, target.id);
+      report.rejected++;
+      continue;
+    }
+    let cos = null;
+    if (fresh.embedding.length > 0 && fresh.embedding.length === target.embedding.length && (fresh.attrs["embeddingVersion"] ?? "") === (target.attrs["embeddingVersion"] ?? "")) {
+      cos = cosine(fresh.embedding, target.embedding);
+    }
+    if (cos !== null && cos >= FOLD_EMBED_AUTO_COSINE) {
+      foldPair(store, fresh, target, opts.ts);
+      report.folded++;
+      report.foldedEmbedding++;
+      continue;
+    }
+    if (cos !== null && cos < FOLD_JUDGE_MIN_COSINE) {
+      clearCandidate(store, fresh, opts.ts, target.id);
+      report.rejected++;
+      continue;
+    }
+    if (!opts.judge) {
+      report.standing++;
+      continue;
+    }
+    let verdict = null;
+    try {
+      verdict = await opts.judge(fresh.description, target.description);
+    } catch {
+      verdict = null;
+    }
+    if (verdict === "same") {
+      foldPair(store, fresh, target, opts.ts);
+      report.folded++;
+      report.foldedJudge++;
+    } else if (verdict === "distinct") {
+      clearCandidate(store, fresh, opts.ts, target.id);
+      report.rejected++;
+    } else {
+      report.judgeErrors++;
+      report.standing++;
+    }
+  }
+  return report;
+}
+function foldPair(store, a, b, ts) {
+  const corro = (n) => Number(n.attrs["corroborations"] ?? 0);
+  const survivor = corro(a) !== corro(b) ? corro(a) > corro(b) ? a : b : a.createdAt <= b.createdAt ? a : b;
+  const dup = survivor === a ? b : a;
+  for (const n of [a, b]) {
+    if (n.attrs["foldCandidate"] !== void 0) clearCandidate(store, n, ts);
+  }
+  const freshSurvivor = store.getNode(survivor.id);
+  const freshDup = store.getNode(dup.id);
+  if (!freshSurvivor || !freshDup) return;
+  foldDuplicateProblem(store, freshDup, freshSurvivor, ts);
+}
+var FOLD_SCOUT_AUTO_COSINE, FOLD_SCOUT_MIN_COSINE, FOLD_SCOUT_MIN_JACCARD, FOLD_EMBED_AUTO_COSINE, FOLD_JUDGE_MIN_COSINE, FOLD_REJECTED_CAP, WORKSPACE_SCAN_CAP, openProblem;
+var init_fold_candidates = __esm({
+  "../../packages/local-graph/src/fold-candidates.ts"() {
+    "use strict";
+    init_src3();
+    init_design_problem();
+    init_problem_dedup();
+    FOLD_SCOUT_AUTO_COSINE = 0.85;
+    FOLD_SCOUT_MIN_COSINE = 0.5;
+    FOLD_SCOUT_MIN_JACCARD = 0.3;
+    FOLD_EMBED_AUTO_COSINE = 0.88;
+    FOLD_JUDGE_MIN_COSINE = 0.5;
+    FOLD_REJECTED_CAP = 8;
+    WORKSPACE_SCAN_CAP = 400;
+    openProblem = (n) => !!n && n.label === "Problem" && n.attrs["resolvedAt"] == null && n.attrs["mergedInto"] === void 0;
+  }
+});
+
 // ../../packages/local-graph/src/tools.ts
 function toolNodeId(name2) {
   return `tool:${name2}`;
@@ -22253,6 +22698,50 @@ var init_mechanism_liveness = __esm({
     STALL_MIN_RUNS = 3;
     STALL_MIN_SPAN_MS = 60 * 60 * 1e3;
     MECHANISMS = [
+      {
+        id: "refute-local-stamp",
+        what: "stamps a harvested refute witness onto the LOCAL node (refutedAt/refutations/reason)",
+        // Stamped at harvest, so the capture pass carries the effect counter.
+        pass: "capture",
+        // Refutes are rare by design (a verdict, not a lean-on) — the bar is "the
+        // field is written at all", the revisitAnsweredWhen precedent. RG-mark
+        // ships the producer; RG-recall is the ranking consumer — until it lands,
+        // THIS descriptor is the consumer, which is exactly the condition the
+        // probe exists to keep visible rather than let rot silently.
+        fed: {
+          labels: ["Problem", "Solution", "RootCause", "Pattern"],
+          attr: "refutedAt",
+          minFraction: 0
+        },
+        effectCounter: "refutesStamped",
+        note: "RG-mark; reason text is local-only (wire ships nodeId+witnessKey)"
+      },
+      {
+        id: "regression-recognize",
+        what: "marks a resolved problem as resolutionSuspect when it recurs at the door",
+        pass: "capture",
+        // Regressions are rare and precious — written-at-all bar, like refutedAt.
+        fed: {
+          labels: ["Problem"],
+          attr: "recurredAt",
+          minFraction: 0
+        },
+        effectCounter: "recurrencesMarked",
+        note: "RG-recognize tier A (exact-id door); tiers B/C add REGRESSION_OF edges; reopen is RG-reopen's"
+      },
+      {
+        id: "regression-reopen",
+        what: "flips a marked close back open once two DISTINCT sessions witnessed the recurrence",
+        pass: "capture",
+        // Reopens should be rarer than recurrences by construction — written-at-all.
+        fed: {
+          labels: ["Problem"],
+          attr: "reopenedFrom",
+          minFraction: 0
+        },
+        effectCounter: "reopenedFromRegression",
+        note: "RG-reopen; the machine sweep never counts as a witness \u2014 only sessions do"
+      },
       {
         id: "fix-candidate-ask",
         what: "asks an agent whether an edit to a problem's anchor fixed it",
@@ -22383,6 +22872,32 @@ var init_mechanism_liveness = __esm({
         backlogCounter: "anchorHintsStanding",
         note: "drains as hinted files change; contentChangedAt is forward-only so the backlog moves with real edits"
       },
+      {
+        id: "fold-candidate-resolve",
+        what: "resolves parked paraphrase-fold nominations (embedding-certain bands auto, ambiguous band via the equivalence judge)",
+        // The settle boundary's fold-judge pass is the sole consumer of
+        // attrs.foldCandidate; producers are the file/workspace scouts (capture)
+        // and the settle near-miss band (mergeProblemsByEmbedding).
+        pass: "fold-judge",
+        // Conditional mark, rare by design (a nomination is a near-miss event) —
+        // the bar is "the field is written at all", the revisit-sweep precedent.
+        fed: { labels: ["Problem"], attr: "foldCandidate", minFraction: 0 },
+        effectCounter: "folded",
+        // Standing nominations ARE the judge-less backlog — without the gauge a
+        // deployment with no judge configured reads as "nothing to fold".
+        backlogCounter: "standing",
+        note: "standing > 0 with folded 0 = the judge lane is unconfigured (ERRATA_FOLD_JUDGE / azure env), not an empty queue"
+      },
+      {
+        id: "cite-anchor-accrual",
+        what: "accrues cite-context anchor evidence on anchorless cited priors; two distinct sessions promote a cite-confirmed ANCHORED_AT",
+        pass: "capture",
+        // Conditional attr: only anchorless semantic priors cited from a known
+        // working file carry hints — "written at all" is the honest floor.
+        fed: { labels: ["Problem"], attr: "citeAnchorHints", minFraction: 0 },
+        effectCounter: "citeAnchorsPromoted",
+        note: "the supply-side fix for corroboration 0-for-8: promoted anchors are what the overlap gate intersects on the NEXT citation"
+      },
       {
         id: "wm-reinforce-exposure",
         what: "labels each paraphrase re-derivation with the prior's exposure (shown/evicted/unshown)",
@@ -22503,6 +23018,12 @@ __export(src_exports2, {
   CREDIT_FAMILY: () => CREDIT_FAMILY,
   DEFAULT_MIN_COVERAGE: () => DEFAULT_MIN_COVERAGE,
   FIX_CANDIDATE_ASK_LIMIT: () => FIX_CANDIDATE_ASK_LIMIT,
+  FOLD_EMBED_AUTO_COSINE: () => FOLD_EMBED_AUTO_COSINE,
+  FOLD_JUDGE_MIN_COSINE: () => FOLD_JUDGE_MIN_COSINE,
+  FOLD_REJECTED_CAP: () => FOLD_REJECTED_CAP,
+  FOLD_SCOUT_AUTO_COSINE: () => FOLD_SCOUT_AUTO_COSINE,
+  FOLD_SCOUT_MIN_COSINE: () => FOLD_SCOUT_MIN_COSINE,
+  FOLD_SCOUT_MIN_JACCARD: () => FOLD_SCOUT_MIN_JACCARD,
   JOINT_COMMUNITY_EDGES: () => JOINT_COMMUNITY_EDGES,
   JOINT_COMMUNITY_LABELS: () => JOINT_COMMUNITY_LABELS,
   MAX_ANCHOR_FILES: () => MAX_ANCHOR_FILES,
@@ -22512,11 +23033,17 @@ __export(src_exports2, {
   PERCOLATING_DRIFT_EDGES: () => PERCOLATING_DRIFT_EDGES,
   PERCOLATING_EDGES: () => PERCOLATING_EDGES,
   PERCOLATING_LABELS: () => PERCOLATING_LABELS,
+  RECURRENCE_DEBOUNCE_MS: () => RECURRENCE_DEBOUNCE_MS,
+  REOPEN_MIN_SOURCES: () => REOPEN_MIN_SOURCES,
   SAME_ANCHOR_DEDUP_JACCARD: () => SAME_ANCHOR_DEDUP_JACCARD,
+  SAME_ANCHOR_NOMINATE_JACCARD: () => SAME_ANCHOR_NOMINATE_JACCARD,
+  SAME_ANCHOR_SCOUT_AUTO_COSINE: () => SAME_ANCHOR_SCOUT_AUTO_COSINE,
+  SAME_ANCHOR_SCOUT_MIN_COSINE: () => SAME_ANCHOR_SCOUT_MIN_COSINE,
   STALL_MIN_RUNS: () => STALL_MIN_RUNS,
   STALL_MIN_SPAN_MS: () => STALL_MIN_SPAN_MS,
   SqliteGraphStore: () => SqliteGraphStore,
   WM_CALIBRATION_LABELS: () => WM_CALIBRATION_LABELS,
+  WORKSPACE_SCAN_CAP: () => WORKSPACE_SCAN_CAP,
   addDependency: () => addDependency,
   aggregateClaimConfidence: () => aggregateClaimConfidence,
   anchorProblemToDiff: () => anchorProblemToDiff,
@@ -22540,6 +23067,7 @@ __export(src_exports2, {
   communityInductionRequests: () => communityInductionRequests,
   communitySeeds: () => communitySeeds,
   compareSemver: () => compareSemver,
+  confirmFixHeld: () => confirmFixHeld,
   corroborateClaim: () => corroborateClaim,
   creditAssignment: () => creditAssignment,
   crystallize: () => crystallize,
@@ -22554,9 +23082,12 @@ __export(src_exports2, {
   findMintTimeDuplicate: () => findMintTimeDuplicate,
   findOrCreatePackage: () => findOrCreatePackage,
   findPath: () => findPath,
+  findResolvedAnchorMatch: () => findResolvedAnchorMatch,
   findReusableSolution: () => findReusableSolution,
+  findWorkspaceFoldCandidate: () => findWorkspaceFoldCandidate,
   flattenCloudCounts: () => flattenCloudCounts,
   foldDuplicateProblem: () => foldDuplicateProblem,
+  foldSameAnchorProblem: () => foldSameAnchorProblem,
   formatMechanismStatus: () => formatMechanismStatus,
   getClaim: () => getClaim,
   harvestAbstractionFences: () => harvestAbstractionFences,
@@ -22576,10 +23107,13 @@ __export(src_exports2, {
   localEdgeViolation: () => localEdgeViolation,
   markDiscriminatorAsked: () => markDiscriminatorAsked,
   markFixCandidates: () => markFixCandidates,
+  markFoldCandidate: () => markFoldCandidate,
+  markResolvedRecurrence: () => markResolvedRecurrence,
   markRevisit: () => markRevisit,
   matchLanguagesInText: () => matchLanguagesInText,
   matchPackagesInText: () => matchPackagesInText,
   matchSymbolsInText: () => matchSymbolsInText,
+  maybeReopenFromRegression: () => maybeReopenFromRegression,
   mergeCloudCounts: () => mergeCloudCounts,
   mergeDuplicateProblems: () => mergeDuplicateProblems,
   migrateProjectAlias: () => migrateProjectAlias,
@@ -22615,6 +23149,7 @@ __export(src_exports2, {
   repairLegacyAnchorsFromStatement: () => repairLegacyAnchorsFromStatement,
   resolveDesignProblemById: () => resolveDesignProblemById,
   resolveDesignProblemByStatement: () => resolveDesignProblemByStatement,
+  resolveFoldCandidates: () => resolveFoldCandidates,
   resolveOsNode: () => resolveOsNode,
   retractDesignProblemById: () => retractDesignProblemById,
   retractDesignProblemByStatement: () => retractDesignProblemByStatement,
@@ -22653,6 +23188,7 @@ var init_src5 = __esm({
     init_community2();
     init_triage2();
     init_problem_dedup();
+    init_fold_candidates();
     init_problem_package_link();
     init_tools();
     init_principle_sync();
@@ -22681,7 +23217,19 @@ function buildSnapshot(opts) {
     anchors: opts.store.outEdges(p.id, ["MANIFESTED_IN", "EVIDENCED_BY"])
   }));
   const recentConstraints = stillOpen.filter((p) => isConstraintProblem(p)).sort((a, b) => b.lastUpdatedAt - a.lastUpdatedAt).slice(0, 3);
-  const recentResolved = problems.filter((p) => p.attrs["resolvedAt"] != null && p.attrs["resolvedAs"] == null).sort((a, b) => Number(b.attrs["resolvedAt"] ?? 0) - Number(a.attrs["resolvedAt"] ?? 0)).slice(0, 4).map((p) => {
+  const regressions = problems.filter((p) => p.attrs["resolvedAt"] == null && p.attrs["mergedInto"] === void 0).flatMap(
+    (open2) => opts.store.outEdges(open2.id, ["REGRESSION_OF"]).flatMap((e) => {
+      const closed = opts.store.getNode(e.to);
+      if (!closed || closed.attrs["resolutionSuspect"] !== true || closed.attrs["resolvedAt"] == null) {
+        return [];
+      }
+      const solEdge = opts.store.outEdges(closed.id, ["SOLVED_BY"])[0];
+      const solution = solEdge ? opts.store.getNode(solEdge.to) ?? void 0 : void 0;
+      return [{ open: open2, closed, ...solution ? { solution } : {} }];
+    })
+  ).sort((a, b) => Number(b.closed.attrs["recurredAt"] ?? 0) - Number(a.closed.attrs["recurredAt"] ?? 0)).slice(0, 2);
+  const regressionClosedIds = new Set(regressions.map((r) => r.closed.id));
+  const recentResolved = problems.filter((p) => p.attrs["resolvedAt"] != null && p.attrs["resolvedAs"] == null).filter((p) => !regressionClosedIds.has(p.id)).sort((a, b) => Number(b.attrs["resolvedAt"] ?? 0) - Number(a.attrs["resolvedAt"] ?? 0)).slice(0, 4).map((p) => {
     const solEdge = opts.store.outEdges(p.id, ["SOLVED_BY"])[0];
     const solution = solEdge ? opts.store.getNode(solEdge.to) ?? void 0 : void 0;
     return { node: p, ...solution ? { solution } : {} };
@@ -22751,6 +23299,7 @@ function buildSnapshot(opts) {
     recentProblems: recent2,
     recentResolved,
     recentConstraints,
+    regressions,
     ...causalNudge ? { causalNudge } : {},
     ...opts.selfCiteSkips && opts.selfCiteSkips > 0 ? { selfCiteSkips: opts.selfCiteSkips } : {},
     ...domainNudge ? { domainNudge } : {},
@@ -22872,6 +23421,14 @@ function renderSnapshot(s) {
     );
     lines.push("");
   }
+  if (s.daemonDistress) {
+    const mins = Math.max(1, Math.round((Date.now() - s.daemonDistress.sinceTs) / 6e4));
+    lines.push("### \u{1F6A8} errata daemon distress");
+    lines.push(
+      `${s.daemonDistress.body} (ongoing ~${mins} min). TELL YOUR USER about this now \u2014 the daemon cannot fix everything itself, and this line may be its only witness. \`errata status\` has detail; a daemon restart (\`errata stop\` then \`errata start\`) is safe mid-session.`
+    );
+    lines.push("");
+  }
   if (s.needsRevisit.length > 0) {
     lines.push("### \u26A0\uFE0F Needs revisit \u2014 a fact these rested on changed");
     lines.push(
@@ -22907,7 +23464,7 @@ function renderSnapshot(s) {
     lines.push("");
   }
   lines.push("### Recently observed problems in this workspace");
-  if (s.recentProblems.length === 0 && s.recentResolved.length === 0 && s.recentConstraints.length === 0) {
+  if (s.recentProblems.length === 0 && s.recentResolved.length === 0 && s.recentConstraints.length === 0 && s.regressions.length === 0) {
     lines.push("- _none yet \u2014 errata is still building its model_");
   } else {
     if (s.recentProblems.length > 0) {
@@ -22929,6 +23486,22 @@ function renderSnapshot(s) {
         );
       }
     }
+    if (s.regressions.length > 0) {
+      lines.push("_\u{1F501} RECURRED \u2014 a previously-solved problem appears to be back; did the fix hold?_");
+      for (const g of s.regressions) {
+        lines.push(`- **${g.open.description}** \u2014 \`${g.open.id}\`${tagOf(g.open)}`);
+        lines.push(`  - previously resolved as: ${g.closed.description.slice(0, 120)} \u2014 \`${g.closed.id}\``);
+        if (g.solution) {
+          lines.push(
+            `  - the fix on record: ${g.solution.description.slice(0, 120)} \u2014 \`${g.solution.id}\` \xB7 fix still holds \u2192 (confirm:[${g.solution.id}]) \xB7 hitting it again \u2192 flag it (a second independent witness reopens the close)`
+          );
+        } else {
+          lines.push(
+            `  - no fix prose on record \xB7 hitting it again \u2192 flag it (a second independent witness reopens the close)`
+          );
+        }
+      }
+    }
     if (s.recentConstraints.length > 0) {
       lines.push("_Design tensions \u2014 constraints this work is shaped around, not defects to fix:_");
       for (const c of s.recentConstraints) {
@@ -22963,12 +23536,31 @@ function renderSnapshot(s) {
   }
   lines.push("");
   if (s.remote && s.remote.length > 0) {
+    const stratumOf = (m) => {
+      const v = m.attrs?.["stratum"];
+      return v === "project" || v === "team" || v === "org" ? v : void 0;
+    };
+    const contributorOf = (m) => {
+      if (stratumOf(m) === void 0) return void 0;
+      const c = m.attrs?.["contributor"];
+      if (!c || typeof c.label !== "string" || c.label.length === 0) return void 0;
+      return { label: c.label, ...typeof c.team === "string" && c.team ? { team: c.team } : {} };
+    };
+    const hasOwnOrg = s.remote.some((m) => stratumOf(m) !== void 0);
     lines.push("### From the Errata Network \u2014 collective priors");
     lines.push(
-      "_A small sample of knowledge from OTHER codebases facing your stack/domain (not yet local \u2014 the Network holds far more; these ids seed deeper bursts). Weigh accordingly \u2014 it's corroborated across teams, but not from this repo._"
+      "_A small sample of knowledge facing your stack/domain (not yet local \u2014 the Network holds far more; these ids seed deeper bursts). Unmarked entries are network-generalized: corroborated across teams, but not from this repo \u2014 treat as pattern and re-derive locally._"
     );
+    if (hasOwnOrg) {
+      lines.push(
+        "_Entries marked `[org]`/`[team]`/`[project]` are from YOUR org's membrane \u2014 specifics are real and checkable; someone here already hit this, so consider coordinating before re-deriving. A `\xB7 name` after the stratum is the authoring installation \u2014 who to coordinate with._"
+      );
+    }
     for (const m of s.remote) {
-      lines.push(`- **${m.label}:** ${m.description}${tagOf(m)}`);
+      const stratum = stratumOf(m);
+      const contributor = contributorOf(m);
+      const chip = stratum ? `\`[${stratum}${contributor ? ` \xB7 ${contributor.label}${contributor.team ? `/${contributor.team}` : ""}` : ""}]\` ` : "";
+      lines.push(`- ${chip}**${m.label}:** ${m.description}${tagOf(m)}`);
     }
     lines.push("");
   }
@@ -23165,6 +23757,7 @@ function assembleAgentContext(opts) {
   });
   if (opts.edgeElicitation) snapshot.edgeElicitation = opts.edgeElicitation;
   if (opts.pendingUpdate) snapshot.pendingUpdate = opts.pendingUpdate;
+  if (opts.daemonDistress) snapshot.daemonDistress = opts.daemonDistress;
   if (opts.reviewItems?.length) snapshot.reviewItems = [...opts.reviewItems];
   if (opts.statedIntent) snapshot.statedIntent = opts.statedIntent;
   if (opts.remote && opts.remote.length > 0) {
@@ -23750,7 +24343,7 @@ function provenanceHeaders(provenance) {
     ...provenance.agentModel ? { "x-inerrata-agent-model": provenance.agentModel } : {}
   };
 }
-var asWireCount, INGEST_NODE_CHUNK, CloudClient, CloudError;
+var asWireCount, INGEST_NODE_CHUNK, E6B_PUBLIC_CONTEXT_SENTINEL, CloudClient, CloudError;
 var init_client = __esm({
   "../../packages/cloud-client/src/client.ts"() {
     "use strict";
@@ -23758,6 +24351,7 @@ var init_client = __esm({
     init_src();
     asWireCount = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0 ? Math.floor(n) : null;
     INGEST_NODE_CHUNK = 8;
+    E6B_PUBLIC_CONTEXT_SENTINEL = "00000000-0000-4e6b-8000-000000000e6b";
     CloudClient = class {
       baseUrl;
       apiKey;
@@ -24149,7 +24743,19 @@ var init_client = __esm({
         if (q.seed?.length) qs.set("seed", q.seed.join(","));
         if (q.q) qs.set("q", q.q);
         if (q.channel) qs.set("channel", q.channel);
-        const res = await this.json("GET", `/v2/search?${qs.toString()}`);
+        const publicCtx = process.env["ERRATA_PRIMING_PUBLIC_CONTEXT"];
+        const usePublicCtx = Boolean(publicCtx && publicCtx !== "0" && q.channel === "priming");
+        const UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+        const res = await this.json(
+          "GET",
+          `/v2/search?${qs.toString()}`,
+          void 0,
+          usePublicCtx ? {
+            extraHeaders: {
+              "X-Inerrata-Project-Id": UUID_RE2.test(publicCtx) ? publicCtx : E6B_PUBLIC_CONTEXT_SENTINEL
+            }
+          } : void 0
+        );
         const { nodes, edges } = this.toCastalia(res);
         return {
           nodes,
@@ -24313,7 +24919,8 @@ var init_client = __esm({
         const headers = {
           "content-type": "application/json",
           accept: "application/json",
-          ...provenanceHeaders(this.provenance)
+          ...provenanceHeaders(this.provenance),
+          ...opts?.extraHeaders ?? {}
         };
         if (!opts?.skipAuth) {
           const token = opts?.bearerToken ?? await this.authToken();
@@ -24527,6 +25134,7 @@ function defaultConfig() {
     // user opts into sync at all.
     consent: { sync: false, telemetry: false, contributePackages: true },
     notifications: true,
+    opsNotices: false,
     onboardedAt: null,
     machineId: null,
     updateChannel: "dev",
@@ -24669,7 +25277,7 @@ var init_config = __esm({
     "use strict";
     init_paths();
     LEGACY_CLOUD_URL = "https://inerrata-gateway.onrender.com";
-    DEFAULT_CLOUD_URL = true ? "https://dev.inerrata.dev" : DEV_CLOUD_URL;
+    DEFAULT_CLOUD_URL = true ? "https://inerrata.dev" : DEV_CLOUD_URL;
   }
 });
 
@@ -28577,7 +29185,13 @@ function generalizeSymbols(text, lexicon, level = 1, fileLexicon) {
   }
   return generalize(out2, { level }).text;
 }
-var SYMBOL_LABELS2, KIND_PHRASE, BUILTIN_TYPE_NAMES, DOC_COMMENT_KINDS, MAX_DOC_CHARS, RE_RESERVED2, escapeRe4, RE_LEADING_ARTICLE2, CONVENTION_FILENAMES, CONVENTION_BASENAME_MIN_FILES, CONVENTION_STEMS, FILE_TOKEN_RE, STEM_TOKEN_RE, SOURCE_EXTENSIONS, TOKEN_RE3;
+function registerRenderedContributorLabels(labels) {
+  for (const label of labels) {
+    const trimmed = label.trim();
+    if (trimmed.length >= 3) renderedContributorLabels.add(trimmed);
+  }
+}
+var SYMBOL_LABELS2, KIND_PHRASE, BUILTIN_TYPE_NAMES, DOC_COMMENT_KINDS, MAX_DOC_CHARS, RE_RESERVED2, escapeRe4, RE_LEADING_ARTICLE2, CONVENTION_FILENAMES, CONVENTION_BASENAME_MIN_FILES, CONVENTION_STEMS, FILE_TOKEN_RE, STEM_TOKEN_RE, SOURCE_EXTENSIONS, TOKEN_RE3, renderedContributorLabels;
 var init_generalize_graph = __esm({
   "src/generalize-graph.ts"() {
     "use strict";
@@ -28718,6 +29332,7 @@ var init_generalize_graph = __esm({
       "cypher"
     ]);
     TOKEN_RE3 = /[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*/g;
+    renderedContributorLabels = /* @__PURE__ */ new Set();
   }
 });
 
@@ -29228,14 +29843,16 @@ function rankOpenProblemNeighbors(store, embedding, limit = 5) {
 }
 function mergeProblemsByEmbedding(store, opts) {
   const minCosine = opts.minCosine ?? NEMORI_DEDUP_COSINE;
-  const report = { clusters: 0, merged: 0 };
+  const NEAR_MISS_FLOOR = 0.72;
+  const report = { clusters: 0, merged: 0, nearMissMarked: 0 };
   const open2 = store.findNodesByLabel("Problem").filter(
     (p) => p.attrs["resolvedAt"] == null && p.attrs["mergedInto"] === void 0 && p.embedding.length > 0
   );
   const corro = (n) => Number(n.attrs["corroborations"] ?? 0);
   const consumed = /* @__PURE__ */ new Set();
+  const seeds = opts.freshSince === void 0 ? open2 : open2.filter((p) => p.createdAt > opts.freshSince);
   store.transaction(() => {
-    for (const a of open2) {
+    for (const a of seeds) {
       if (consumed.has(a.id)) continue;
       const cluster = [a];
       for (const b of open2) {
@@ -29243,9 +29860,15 @@ function mergeProblemsByEmbedding(store, opts) {
         if (b.embedding.length !== a.embedding.length) continue;
         if ((a.attrs["embeddingVersion"] ?? "") !== (b.attrs["embeddingVersion"] ?? "")) continue;
         if (isConstraintProblem(a) !== isConstraintProblem(b)) continue;
-        if (cosine(a.embedding, b.embedding) >= minCosine) {
+        const cos = cosine(a.embedding, b.embedding);
+        if (cos >= minCosine) {
           cluster.push(b);
           consumed.add(b.id);
+        } else if (cos >= NEAR_MISS_FLOOR) {
+          const [younger, elder] = a.createdAt >= b.createdAt ? [a, b] : [b, a];
+          if (markFoldCandidate(store, younger.id, elder.id, { hashCos: cos, source: "settle-nearmiss", ts: opts.ts })) {
+            report.nearMissMarked = (report.nearMissMarked ?? 0) + 1;
+          }
         }
       }
       if (cluster.length < 2) continue;
@@ -29260,6 +29883,50 @@ function mergeProblemsByEmbedding(store, opts) {
   });
   return report;
 }
+function bindResolvedRegressions(store, opts) {
+  const minCosine = opts.minCosine ?? NEMORI_DEDUP_COSINE;
+  const watermarkRaw = store.getMeta?.("regression_sweep_at") ?? null;
+  const full = watermarkRaw === null;
+  const since = full ? 0 : Number(watermarkRaw) || 0;
+  const live2 = (n) => n.attrs["mergedInto"] === void 0;
+  const problems = store.findNodesByLabel("Problem").filter((p) => p.embedding.length > 0 && live2(p));
+  const fresh = problems.filter((p) => p.attrs["resolvedAt"] == null && p.createdAt > since);
+  const resolved = problems.filter(
+    (p) => p.attrs["resolvedAt"] != null && p.attrs["resolvedAs"] == null
+  );
+  const report = { scanned: fresh.length, bound: 0, full };
+  if (fresh.length > 0 && resolved.length > 0) {
+    for (const f of fresh) {
+      let best = null;
+      for (const r of resolved) {
+        if (r.embedding.length !== f.embedding.length) continue;
+        if ((r.attrs["embeddingVersion"] ?? "") !== (f.attrs["embeddingVersion"] ?? "")) continue;
+        if (isConstraintProblem(f) !== isConstraintProblem(r)) continue;
+        const s = cosine(f.embedding, r.embedding);
+        if (s >= minCosine && (!best || s > best.s)) best = { node: r, s };
+      }
+      if (!best) continue;
+      if (store.outEdges(f.id, ["REGRESSION_OF"]).some((e) => e.to === best.node.id)) continue;
+      if (!markResolvedRecurrence(store, best.node.id, opts.ts).marked) continue;
+      store.mergeEdge({
+        id: `edge_${digest({ from: f.id, type: "REGRESSION_OF", to: best.node.id })}`.slice(0, 24),
+        from: f.id,
+        to: best.node.id,
+        type: "REGRESSION_OF",
+        confidence: 0.5,
+        extractionSource: "daemon-extracted",
+        createdAt: opts.ts,
+        lastSeenAt: opts.ts,
+        navSuccesses: 0,
+        navFailures: 0,
+        attrs: { provisional: true, machineProposed: true, cosine: Math.round(best.s * 100) / 100 }
+      });
+      report.bound++;
+    }
+  }
+  store.setMeta?.("regression_sweep_at", String(opts.ts));
+  return report;
+}
 function bindCanonicalNeighbors(store, opts) {
   const k = opts.k ?? 3;
   const live2 = (n) => n.attrs["mergedInto"] === void 0;
@@ -30741,6 +31408,7 @@ __export(src_exports4, {
   annotateResolution: () => annotateResolution,
   attributeRootCause: () => attributeRootCause,
   bindCanonicalNeighbors: () => bindCanonicalNeighbors,
+  bindResolvedRegressions: () => bindResolvedRegressions,
   closeProblem: () => closeProblem,
   codeAnchorProjection: () => codeAnchorProjection,
   commandSignature: () => commandSignature,
@@ -39686,6 +40354,8 @@ var init_reconcile = __esm({
 var mcp_exports = {};
 __export(mcp_exports, {
   INSTRUCTIONS: () => INSTRUCTIONS,
+  RG_REFUTED_DAMP: () => RG_REFUTED_DAMP,
+  RG_SUSPECT_BOOST: () => RG_SUSPECT_BOOST,
   createMcpHandler: () => createMcpHandler,
   runMcpServer: () => runMcpServer,
   runTool: () => runTool,
@@ -39757,6 +40427,22 @@ function takeDiscriminatorNudge(path2) {
     shared.close();
   }
 }
+function hitState(n) {
+  const reasons = n.attrs["refuteReasons"];
+  if (n.attrs["resolutionSuspect"] === true && n.attrs["resolvedAt"] != null) {
+    return { state: "regression-suspect", factor: RG_SUSPECT_BOOST };
+  }
+  if (n.attrs["refutedAt"] != null) {
+    return { state: "refuted", ...reasons?.[0] ? { refutedWhy: reasons[0] } : {}, factor: RG_REFUTED_DAMP };
+  }
+  if (n.attrs["reopenedFrom"] === "regression") {
+    return { state: "reopened-regression", factor: RG_SUSPECT_BOOST };
+  }
+  if (n.attrs["resolvedAt"] != null && n.attrs["resolvedAs"] == null) {
+    return { state: "resolved", factor: 1 };
+  }
+  return { factor: 1 };
+}
 function commentAnchorId(store, commentId) {
   const out2 = store.outEdges(commentId, ["EXPLAINS", "ANNOTATES"]);
   if (out2.length > 0) return out2[0].to;
@@ -39821,14 +40507,16 @@ function searchGraph(store, query, limit) {
     }
     add(node2, matched);
   }
-  return [...merged.values()].sort(
-    (a, b) => rankTier(a.node) - rankTier(b.node) || b.matched - a.matched || b.node.pageRank - a.node.pageRank
-  ).slice(0, limit).map(({ node: node2, via }) => ({
+  return [...merged.values()].map((e) => ({ ...e, rg: hitState(e.node) })).sort(
+    (a, b) => rankTier(a.node) - rankTier(b.node) || b.matched - a.matched || b.node.pageRank * b.rg.factor - a.node.pageRank * a.rg.factor
+  ).slice(0, limit).map(({ node: node2, via, rg }) => ({
     id: node2.id,
     label: node2.label,
     description: node2.description,
     pageRank: node2.pageRank,
-    ...via ? { via } : {}
+    ...via ? { via } : {},
+    ...rg.state ? { state: rg.state } : {},
+    ...rg.refutedWhy ? { refutedWhy: rg.refutedWhy } : {}
   }));
 }
 function runTool(name2, args2, store, ctx = {}) {
@@ -39970,7 +40658,10 @@ function unresolved(args2) {
   const q = args2["qname"] ?? args2["nodeId"];
   return { found: false, reason: "unresolved", query: typeof q === "string" ? q : "" };
 }
-function createMcpHandler(store, ctx = {}) {
+function createMcpHandler(store, ctx = {}, options = {}) {
+  const bareToolNames = options.toolNameStyle === "bare";
+  const publicToolName = (canonical) => bareToolNames ? canonical.replace(/^errata\./, "") : canonical;
+  const canonicalToolName = (presented) => bareToolNames && presented && !presented.includes(".") ? `errata.${presented}` : presented;
   let auditReadRun = 0;
   let toolCallIndex = 0;
   let lastAuditNudgeAt = Number.NEGATIVE_INFINITY;
@@ -40000,7 +40691,7 @@ function createMcpHandler(store, ctx = {}) {
             id,
             result: {
               tools: TOOLS.map((t) => ({
-                name: t.name,
+                name: publicToolName(t.name),
                 description: t.description,
                 inputSchema: t.inputSchema
               }))
@@ -40008,7 +40699,8 @@ function createMcpHandler(store, ctx = {}) {
           };
         case "tools/call": {
           const params = req.params ?? {};
-          const tool = TOOLS.find((t) => t.name === params.name);
+          const requestedToolName = canonicalToolName(params.name);
+          const tool = TOOLS.find((t) => t.name === requestedToolName);
           if (!tool) {
             return {
               jsonrpc: "2.0",
@@ -40020,8 +40712,8 @@ function createMcpHandler(store, ctx = {}) {
           const content = [
             { type: "text", text: JSON.stringify(out2, null, 2) }
           ];
-          const isEnrichmentTool = params.name === "errata.pending_enrichment" || params.name === "errata.annotate_resolution";
-          const isTriageTool = params.name === "errata.pending_discriminators" || params.name === "errata.triage";
+          const isEnrichmentTool = requestedToolName === "errata.pending_enrichment" || requestedToolName === "errata.annotate_resolution";
+          const isTriageTool = requestedToolName === "errata.pending_discriminators" || requestedToolName === "errata.triage";
           toolCallIndex++;
           auditReadRun = isEnrichmentTool ? 0 : auditReadRun + 1;
           if (!isEnrichmentTool) {
@@ -40087,13 +40779,13 @@ function buildToolContext(workspaceRoot) {
   }
   return base;
 }
-async function runMcpServer(workspaceRoot) {
+async function runMcpServer(workspaceRoot, options = {}) {
   const paths = workspacePaths(workspaceRoot);
   const store = openGraphStore({ path: paths.castalia });
   const handle2 = createMcpHandler(store, {
     ...buildToolContext(workspaceRoot),
     sharedDbPath: sharedStorePath()
-  });
+  }, options);
   process.stdin.setEncoding("utf8");
   let buffer = "";
   process.stdin.on("data", (chunk) => {
@@ -40121,7 +40813,7 @@ async function runMcpServer(workspaceRoot) {
     if (resp) process.stdout.write(JSON.stringify(resp) + "\n");
   }
 }
-var INSTRUCTIONS, AUDIT_RUN_THRESHOLD, AUDIT_NUDGE_COOLDOWN, DISCRIMINATOR_NUDGE_COOLDOWN, AUDIT_FLAG_NUDGE, TOOLS;
+var INSTRUCTIONS, AUDIT_RUN_THRESHOLD, AUDIT_NUDGE_COOLDOWN, DISCRIMINATOR_NUDGE_COOLDOWN, AUDIT_FLAG_NUDGE, RG_REFUTED_DAMP, RG_SUSPECT_BOOST, TOOLS;
 var init_mcp = __esm({
   "src/mcp.ts"() {
     "use strict";
@@ -40185,6 +40877,8 @@ var init_mcp = __esm({
     AUDIT_NUDGE_COOLDOWN = 12;
     DISCRIMINATOR_NUDGE_COOLDOWN = 40;
     AUDIT_FLAG_NUDGE = "\u26A1 errata \u2014 reading/auditing? anything you notice that's off, flag it inline as `[!one line]` (`[?\u2026]` = TODO) \u2014 no tool call, we harvest it.";
+    RG_REFUTED_DAMP = 0.75;
+    RG_SUSPECT_BOOST = 1.25;
     TOOLS = [
       {
         name: "errata.switch_context",
@@ -52676,6 +53370,7 @@ function watch(paths, options = {}) {
 var esm_default = { watch, FSWatcher };
 
 // src/engine.ts
+init_generalize_graph();
 init_src();
 init_src2();
 init_src5();
@@ -52837,6 +53532,91 @@ function openEventLog(opts) {
   return new EventLog(opts);
 }
 
+// src/llm-provider.ts
+function chatProvider() {
+  return (process.env["EXTRACTION_PROVIDER"] ?? "azure").toLowerCase() === "anthropic" ? "anthropic" : "azure";
+}
+function deploymentFor(model) {
+  const key = `MODEL_${model.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_OPENAI`;
+  return process.env[key] ?? process.env["AZURE_OPENAI_DEPLOYMENT"];
+}
+function isChatConfigured(model) {
+  if (chatProvider() === "azure") {
+    return Boolean(
+      process.env["AZURE_OPENAI_API_KEY"] && process.env["AZURE_OPENAI_ENDPOINT"] && deploymentFor(model)
+    );
+  }
+  return Boolean(process.env["ANTHROPIC_API_KEY"]);
+}
+async function chat(req) {
+  const provider = chatProvider();
+  try {
+    if (provider === "azure") {
+      const endpoint = (process.env["AZURE_OPENAI_ENDPOINT"] ?? "").replace(/\/+$/, "");
+      const version2 = process.env["AZURE_OPENAI_API_VERSION"] ?? "2024-10-21";
+      const deployment = deploymentFor(req.model);
+      if (!endpoint || !deployment) {
+        console.warn("[errata] llm: azure selected but endpoint/deployment missing \u2014 skipping");
+        return null;
+      }
+      const resp2 = await fetch(
+        `${endpoint}/openai/deployments/${deployment}/chat/completions?api-version=${version2}`,
+        {
+          method: "POST",
+          headers: {
+            "api-key": process.env["AZURE_OPENAI_API_KEY"] ?? "",
+            "content-type": "application/json"
+          },
+          body: JSON.stringify({
+            messages: [
+              ...req.system ? [{ role: "system", content: req.system }] : [],
+              { role: "user", content: req.user }
+            ],
+            // `max_completion_tokens`: the newer deployments reject `max_tokens`.
+            max_completion_tokens: req.maxTokens
+          })
+        }
+      );
+      if (!resp2.ok) {
+        console.warn(
+          `[errata] llm: azure ${resp2.status} \u2014 ${(await resp2.text().catch(() => "")).slice(0, 200)}`
+        );
+        return null;
+      }
+      const json3 = await resp2.json();
+      return json3.choices?.[0]?.message?.content ?? null;
+    }
+    const resp = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": process.env["ANTHROPIC_API_KEY"] ?? "",
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: req.model,
+        max_tokens: req.maxTokens,
+        ...req.system ? { system: req.system } : {},
+        messages: [{ role: "user", content: req.user }]
+      })
+    });
+    if (!resp.ok) {
+      console.warn(
+        `[errata] llm: anthropic ${resp.status} \u2014 ${(await resp.text().catch(() => "")).slice(0, 200)}`
+      );
+      return null;
+    }
+    const json2 = await resp.json();
+    return json2.content?.find((c) => c.type === "text")?.text ?? null;
+  } catch (err2) {
+    console.warn(
+      `[errata] llm: ${provider} transport failed \u2014`,
+      err2 instanceof Error ? err2.message : err2
+    );
+    return null;
+  }
+}
+
 // src/engine.ts
 init_src11();
 init_src6();
@@ -52844,9 +53624,10 @@ init_src10();
 init_review2();
 
 // src/turn.ts
-import { closeSync, existsSync as existsSync13, fstatSync, openSync, readdirSync as readdirSync6, readSync, statSync as statSync4 } from "node:fs";
+import { closeSync, existsSync as existsSync13, fstatSync, openSync, readdirSync as readdirSync6, readSync, realpathSync, statSync as statSync4 } from "node:fs";
 import { basename as basename3, dirname as dirname8, join as join16 } from "node:path";
 import { homedir as homedir4 } from "node:os";
+import { createHash as createHash13 } from "node:crypto";
 function readFrom(path2, fromByte, maxBytes) {
   let fd;
   try {
@@ -52964,6 +53745,8 @@ function parseDesignResolutions(text) {
   }
   return out2;
 }
+var OPENCODE_PARSER_PINNED_VERSION = "1.18.18";
+var OPENCODE_TRANSCRIPT_HEADER_TYPE = "errata-opencode-session";
 var FILE_TOOLS = /* @__PURE__ */ new Set(["Read", "Edit", "Write", "MultiEdit", "NotebookEdit"]);
 var WRITE_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
 function isUserTurnBoundary(obj) {
@@ -52997,7 +53780,161 @@ function readAssistantTurnsFrom(transcriptPath, fromByte, includeThinking = true
     losses: { parseFailures: parsed.parseFailures, ioFailed, bytesUnreachable: 0 }
   };
 }
+var CODEX_PARSER_PINNED_VERSION = "0.144.5";
+function detectHostHarness(raw2) {
+  const lines = raw2.split(/\r?\n/);
+  let checked = 0;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    if (checked++ >= 5) break;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (obj.type === "response_item" || obj.type === "event_msg" || obj.type === "session_meta" || obj.type === "turn_context" || obj.type === "world_state") {
+      return "codex";
+    }
+    if (obj.type === "gemini" || "$set" in obj || "projectHash" in obj && "sessionId" in obj || obj.type === "user" && !("message" in obj) && "content" in obj) {
+      return "gemini";
+    }
+    if (obj.type === OPENCODE_TRANSCRIPT_HEADER_TYPE || obj.type === void 0 && "info" in obj && Array.isArray(obj["parts"]) && typeof obj["info"]?.["role"] === "string") {
+      return "opencode";
+    }
+    if (obj.type === "user" || obj.type === "assistant" || obj.type === "summary") {
+      return "claude_code";
+    }
+  }
+  return "claude_code";
+}
 function parseAssistantTurns(raw2, includeThinking, skipFirstLineParseFailure = false) {
+  if (!raw2) return { turns: [], parseFailures: 0 };
+  const harness = detectHostHarness(raw2);
+  if (harness === "codex") return parseCodexAssistantTurns(raw2, skipFirstLineParseFailure);
+  if (harness === "gemini") return parseGeminiAssistantTurns(raw2, skipFirstLineParseFailure);
+  if (harness === "opencode") return parseOpencodeAssistantTurns(raw2, skipFirstLineParseFailure);
+  return parseClaudeAssistantTurns(raw2, includeThinking, skipFirstLineParseFailure);
+}
+function parseOpencodeAssistantTurns(raw2, skipFirstLineParseFailure = false) {
+  const lines = raw2.split(/\r?\n/);
+  const byId = /* @__PURE__ */ new Map();
+  let order = 0;
+  let parseFailures = 0;
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const line = lines[i2];
+    if (!line) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      if (!(i2 === 0 && skipFirstLineParseFailure)) parseFailures++;
+      continue;
+    }
+    if (!obj || typeof obj !== "object") continue;
+    if (obj["type"] === OPENCODE_TRANSCRIPT_HEADER_TYPE) continue;
+    const info2 = obj["info"];
+    const parts2 = obj["parts"];
+    if (!info2 || typeof info2 !== "object" || !Array.isArray(parts2)) continue;
+    if (info2["role"] !== "assistant") continue;
+    const texts = [];
+    for (const p of parts2) {
+      if (!p || p["type"] !== "text") continue;
+      if (p["synthetic"] === true || p["ignored"] === true) continue;
+      if (typeof p["text"] === "string" && p["text"].length > 0) texts.push(p["text"]);
+    }
+    if (texts.length === 0) continue;
+    const id = typeof info2["id"] === "string" ? info2["id"] : `opencode-${i2}`;
+    const prev = byId.get(id);
+    byId.set(id, { text: texts.join("\n\n"), order: prev ? prev.order : order++ });
+  }
+  const turns = [...byId.entries()].sort((a, b) => a[1].order - b[1].order).map(([uuid3, v]) => ({ uuid: uuid3, text: v.text, hostHarness: "opencode" }));
+  return { turns, parseFailures };
+}
+function parseGeminiAssistantTurns(raw2, skipFirstLineParseFailure = false) {
+  const lines = raw2.split(/\r?\n/);
+  const byId = /* @__PURE__ */ new Map();
+  let order = 0;
+  let parseFailures = 0;
+  const textOf = (content) => {
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+      const parts2 = [];
+      for (const b of content) {
+        if (b && typeof b["text"] === "string") parts2.push(b["text"]);
+      }
+      return parts2.length > 0 ? parts2.join("\n\n") : null;
+    }
+    return null;
+  };
+  const fold = (m, fallbackId) => {
+    if (m["type"] !== "gemini") return;
+    const text = textOf(m["content"]);
+    if (text === null || text.length === 0) return;
+    const id = typeof m["id"] === "string" ? m["id"] : fallbackId;
+    const prev = byId.get(id);
+    byId.set(id, { text, order: prev ? prev.order : order++ });
+  };
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const line = lines[i2];
+    if (!line) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      if (!(i2 === 0 && skipFirstLineParseFailure)) parseFailures++;
+      continue;
+    }
+    if (!obj || typeof obj !== "object") continue;
+    const set2 = obj["$set"];
+    if (set2 && typeof set2 === "object") {
+      const msgs = set2["messages"];
+      if (Array.isArray(msgs)) {
+        for (let j = 0; j < msgs.length; j++) {
+          const m = msgs[j];
+          if (m && typeof m === "object") fold(m, `gemini-${i2}-${j}`);
+        }
+      }
+      continue;
+    }
+    if (typeof obj["type"] === "string") fold(obj, `gemini-${i2}`);
+  }
+  const turns = [...byId.entries()].sort((a, b) => a[1].order - b[1].order).map(([uuid3, v]) => ({ uuid: uuid3, text: v.text, hostHarness: "gemini" }));
+  return { turns, parseFailures };
+}
+function parseCodexAssistantTurns(raw2, skipFirstLineParseFailure = false) {
+  const turns = [];
+  const lines = raw2.split(/\r?\n/);
+  let parseFailures = 0;
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const line = lines[i2];
+    if (!line) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      if (!(i2 === 0 && skipFirstLineParseFailure)) parseFailures++;
+      continue;
+    }
+    if (obj.type !== "response_item") continue;
+    const payload = obj.payload;
+    if (!payload || payload["type"] !== "message" || payload["role"] !== "assistant") continue;
+    const content = payload["content"];
+    if (!Array.isArray(content)) continue;
+    const parts2 = [];
+    for (const b of content) {
+      if (b["type"] === "output_text" && typeof b["text"] === "string") parts2.push(b["text"]);
+    }
+    if (parts2.length === 0) continue;
+    turns.push({
+      uuid: typeof payload["id"] === "string" ? payload["id"] : `codex-${i2}`,
+      text: parts2.join("\n\n"),
+      hostHarness: "codex"
+    });
+  }
+  return { turns, parseFailures };
+}
+function parseClaudeAssistantTurns(raw2, includeThinking, skipFirstLineParseFailure = false) {
   if (!raw2) return { turns: [], parseFailures: 0 };
   const turns = [];
   const lines = raw2.split(/\r?\n/);
@@ -53051,6 +53988,7 @@ function parseAssistantTurns(raw2, includeThinking, skipFirstLineParseFailure =
     turns.push({
       uuid: String(obj.uuid ?? i2),
       text: parts2.join("\n\n"),
+      hostHarness: "claude_code",
       ...lastFile ? { workingFile: lastFile } : {},
       ...provenance ? { workingFileProvenance: provenance } : {},
       ...editedFile && editedFileTurnSeq === turnSeq ? { editedFile } : {},
@@ -53118,6 +54056,237 @@ function subagentTranscripts(mainTranscriptPath, sessionId) {
   refs.sort((a, b) => b.mtimeMs - a.mtimeMs);
   return refs;
 }
+function codexSessionRoots(env2 = process.env, home = homedir4()) {
+  const roots = /* @__PURE__ */ new Set();
+  const explicit = env2["ERRATA_CODEX_SESSIONS_DIRS"];
+  if (explicit) {
+    for (const d of explicit.split(":")) if (d.trim()) roots.add(d.trim());
+  }
+  if (env2["CODEX_HOME"]) roots.add(join16(env2["CODEX_HOME"], "sessions"));
+  roots.add(join16(home, ".codex", "sessions"));
+  return [...roots];
+}
+function readCodexRolloutCwd(path2) {
+  let fd;
+  try {
+    fd = openSync(path2, "r");
+    const CAP = 1e6;
+    const chunk = 65536;
+    let acc = Buffer.alloc(0);
+    let pos = 0;
+    let nl = -1;
+    while (acc.length < CAP) {
+      const buf = Buffer.allocUnsafe(chunk);
+      const n = readSync(fd, buf, 0, chunk, pos);
+      if (n <= 0) break;
+      acc = acc.length === 0 ? buf.subarray(0, n) : Buffer.concat([acc, buf.subarray(0, n)]);
+      pos += n;
+      nl = acc.indexOf(10);
+      if (nl >= 0) break;
+    }
+    const firstLine = acc.toString("utf8", 0, nl >= 0 ? nl : acc.length);
+    try {
+      const o = JSON.parse(firstLine);
+      const meta3 = o?.type === "session_meta" ? o.payload ?? o : o.payload ?? o;
+      const cwd = meta3?.cwd ?? o?.cwd;
+      if (typeof cwd === "string") return cwd;
+    } catch {
+    }
+    const m = firstLine.match(/"cwd"\s*:\s*"((?:[^"\\]|\\.)*)"/);
+    return m ? JSON.parse(`"${m[1]}"`) : null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== void 0) try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+function codexRolloutsForCwd(cwd, opts = {}) {
+  const sinceMs = opts.sinceMs ?? 0;
+  const limit = opts.limit ?? 25;
+  const out2 = [];
+  for (const root of codexSessionRoots(opts.env, opts.home)) {
+    if (!existsSync13(root)) continue;
+    const stack = [{ dir: root, depth: 0 }];
+    while (stack.length > 0) {
+      const { dir, depth } = stack.pop();
+      let names;
+      try {
+        names = readdirSync6(dir);
+      } catch {
+        continue;
+      }
+      for (const name2 of names) {
+        const full = join16(dir, name2);
+        let st;
+        try {
+          st = statSync4(full);
+        } catch {
+          continue;
+        }
+        if (st.isDirectory()) {
+          if (depth < 3) stack.push({ dir: full, depth: depth + 1 });
+          continue;
+        }
+        if (depth < 3) continue;
+        if (!name2.startsWith("rollout-") || !name2.endsWith(".jsonl")) continue;
+        if (st.mtimeMs < sinceMs) continue;
+        if (readCodexRolloutCwd(full) !== cwd) continue;
+        out2.push({ path: full, sessionId: `codex:${basename3(name2, ".jsonl")}`, mtimeMs: st.mtimeMs });
+      }
+    }
+  }
+  out2.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return out2.slice(0, limit);
+}
+function geminiSessionRoots(env2 = process.env, home = homedir4()) {
+  const roots = /* @__PURE__ */ new Set();
+  const explicit = env2["ERRATA_GEMINI_SESSIONS_DIRS"];
+  if (explicit) {
+    for (const d of explicit.split(":")) if (d.trim()) roots.add(d.trim());
+  }
+  if (env2["GEMINI_CLI_HOME"]) roots.add(join16(env2["GEMINI_CLI_HOME"], ".gemini", "tmp"));
+  roots.add(join16(home, ".gemini", "tmp"));
+  return [...roots];
+}
+function geminiProjectHash(cwd) {
+  return createHash13("sha256").update(cwd).digest("hex");
+}
+function geminiHashesFor(cwd) {
+  const variants = /* @__PURE__ */ new Set([cwd, cwd.replace(/\/+$/, "")]);
+  try {
+    variants.add(realpathSync(cwd));
+  } catch {
+  }
+  return new Set([...variants].map(geminiProjectHash));
+}
+function readGeminiTranscriptProjectHash(path2) {
+  let fd;
+  try {
+    fd = openSync(path2, "r");
+    const CAP = 65536;
+    const buf = Buffer.allocUnsafe(CAP);
+    const n = readSync(fd, buf, 0, CAP, 0);
+    const nl = buf.indexOf(10);
+    const firstLine = buf.toString("utf8", 0, nl >= 0 && nl < n ? nl : n);
+    const o = JSON.parse(firstLine);
+    return typeof o?.projectHash === "string" ? o.projectHash : null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== void 0) try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+function geminiTranscriptsForCwd(cwd, opts = {}) {
+  const sinceMs = opts.sinceMs ?? 0;
+  const limit = opts.limit ?? 25;
+  const hashes = geminiHashesFor(cwd);
+  const out2 = [];
+  for (const root of geminiSessionRoots(opts.env, opts.home)) {
+    if (!existsSync13(root)) continue;
+    let slugs;
+    try {
+      slugs = readdirSync6(root);
+    } catch {
+      continue;
+    }
+    for (const slug2 of slugs) {
+      const chats = join16(root, slug2, "chats");
+      let names;
+      try {
+        names = readdirSync6(chats);
+      } catch {
+        continue;
+      }
+      for (const name2 of names) {
+        if (!name2.startsWith("session-") || !name2.endsWith(".jsonl")) continue;
+        const full = join16(chats, name2);
+        let st;
+        try {
+          st = statSync4(full);
+        } catch {
+          continue;
+        }
+        if (!st.isFile() || st.mtimeMs < sinceMs) continue;
+        const h = readGeminiTranscriptProjectHash(full);
+        if (!h || !hashes.has(h)) continue;
+        out2.push({ path: full, sessionId: `gemini:${basename3(name2, ".jsonl")}`, mtimeMs: st.mtimeMs });
+      }
+    }
+  }
+  out2.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return out2.slice(0, limit);
+}
+function opencodeSessionRoots(env2 = process.env, home = homedir4()) {
+  const roots = /* @__PURE__ */ new Set();
+  const explicit = env2["ERRATA_OPENCODE_SESSIONS_DIRS"];
+  if (explicit) {
+    for (const d of explicit.split(":")) if (d.trim()) roots.add(d.trim());
+  }
+  if (env2["XDG_DATA_HOME"]) roots.add(join16(env2["XDG_DATA_HOME"], "opencode", "errata"));
+  roots.add(join16(home, ".local", "share", "opencode", "errata"));
+  return [...roots];
+}
+function readOpencodeTranscriptDirectory(path2) {
+  let fd;
+  try {
+    fd = openSync(path2, "r");
+    const buf = Buffer.allocUnsafe(8192);
+    const n = readSync(fd, buf, 0, buf.length, 0);
+    const nl = buf.indexOf(10);
+    const first = buf.toString("utf8", 0, nl >= 0 && nl < n ? nl : n);
+    const o = JSON.parse(first);
+    if (o?.type !== OPENCODE_TRANSCRIPT_HEADER_TYPE) return null;
+    return typeof o.directory === "string" ? o.directory : null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== void 0) try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+function opencodeTranscriptsForCwd(cwd, opts = {}) {
+  const sinceMs = opts.sinceMs ?? 0;
+  const limit = opts.limit ?? 25;
+  const want = /* @__PURE__ */ new Set([cwd, cwd.replace(/\/+$/, "")]);
+  try {
+    want.add(realpathSync(cwd));
+  } catch {
+  }
+  const out2 = [];
+  for (const root of opencodeSessionRoots(opts.env, opts.home)) {
+    if (!existsSync13(root)) continue;
+    let names;
+    try {
+      names = readdirSync6(root);
+    } catch {
+      continue;
+    }
+    for (const name2 of names) {
+      if (!name2.endsWith(".jsonl")) continue;
+      const full = join16(root, name2);
+      let st;
+      try {
+        st = statSync4(full);
+      } catch {
+        continue;
+      }
+      if (!st.isFile() || st.mtimeMs < sinceMs) continue;
+      const dir = readOpencodeTranscriptDirectory(full);
+      if (!dir || !(want.has(dir) || want.has(dir.replace(/\/+$/, "")))) continue;
+      out2.push({ path: full, sessionId: `opencode:${basename3(name2, ".jsonl")}`, mtimeMs: st.mtimeMs });
+    }
+  }
+  out2.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return out2.slice(0, limit);
+}
 
 // src/prior-tags.ts
 init_src();
@@ -53596,6 +54765,44 @@ function typePriorEdge(sourceLabel, targetLabel2, sentence = "") {
   }
   return "RELATES_TO";
 }
+function refuteReason(statement) {
+  const s = (statement ?? "").trim();
+  return s.length > 0 ? s.slice(0, 240) : void 0;
+}
+function wireWitnessItems(items) {
+  return items.map(({ nodeId, witnessKey }) => ({ nodeId, witnessKey }));
+}
+var REFUTE_REASONS_CAP = 5;
+var REFUTE_WITNESS_KEYS_CAP = 16;
+function applyLocalRefutations(store, refutes, ts) {
+  const out2 = { stamped: 0, duplicate: 0, unknownNode: 0, stampedIds: [] };
+  for (const r of refutes) {
+    const node2 = store.getNode(r.nodeId);
+    if (!node2) {
+      out2.unknownNode++;
+      continue;
+    }
+    const keys = node2.attrs["refuteWitnessKeys"] ?? [];
+    if (keys.includes(r.witnessKey)) {
+      out2.duplicate++;
+      continue;
+    }
+    const reasons = node2.attrs["refuteReasons"] ?? [];
+    store.updateNode(r.nodeId, {
+      attrs: {
+        ...node2.attrs,
+        refutedAt: ts,
+        refutations: (Number(node2.attrs["refutations"]) || 0) + 1,
+        ...r.reason ? { refuteReasons: [r.reason, ...reasons].slice(0, REFUTE_REASONS_CAP) } : {},
+        refuteWitnessKeys: [...keys, r.witnessKey].slice(-REFUTE_WITNESS_KEYS_CAP)
+      },
+      lastUpdatedAt: ts
+    });
+    out2.stamped++;
+    out2.stampedIds.push(r.nodeId);
+  }
+  return out2;
+}
 var PRIOR_TAG_INSTRUCTION = buildAgentInstruction();
 function isEdgeElicitationEnabled() {
   return (process.env["EDGE_ELICITATION_ENABLED"] ?? "true").toLowerCase() !== "false";
@@ -53634,7 +54841,52 @@ function readPrimingHandles(path2) {
 function resolveHandle(store, handle2, handleMap) {
   return handleMap[handle2]?.id ?? (store.getNode(handle2) ? handle2 : void 0);
 }
-function mintPriorEdge(store, source, target, sentence, touched, ts) {
+var CITE_ANCHOR_LABELS = /* @__PURE__ */ new Set(["Problem", "Solution", "RootCause", "Pattern", "Claim", "Technique", "AntiPattern"]);
+var CITE_ANCHOR_PROMOTE_SESSIONS = 2;
+var CITE_ANCHOR_MAX_FILES = 4;
+var CITE_ANCHOR_MAX_SESSIONS = 6;
+function accrueCiteAnchor(store, targetId, touched, sessionId, ts) {
+  let fileId;
+  for (const tid of touched) {
+    if (store.getNode(tid)?.label === "File") {
+      fileId = tid;
+      break;
+    }
+  }
+  if (!fileId) return { accrued: false, promoted: false };
+  const node2 = store.getNode(targetId);
+  if (!node2) return { accrued: false, promoted: false };
+  const hints = { ...node2.attrs["citeAnchorHints"] ?? {} };
+  const entry = hints[fileId] ?? [];
+  if (entry.includes(sessionId)) return { accrued: false, promoted: false };
+  if (hints[fileId] === void 0 && Object.keys(hints).length >= CITE_ANCHOR_MAX_FILES) {
+    return { accrued: false, promoted: false };
+  }
+  const grown = [...entry, sessionId].slice(-CITE_ANCHOR_MAX_SESSIONS);
+  let promoted = false;
+  if (grown.length >= CITE_ANCHOR_PROMOTE_SESSIONS) {
+    store.mergeEdge({
+      id: `edge_${digest({ from: targetId, type: "ANCHORED_AT", to: fileId })}`.slice(0, 24),
+      from: targetId,
+      to: fileId,
+      type: "ANCHORED_AT",
+      confidence: 0.3,
+      extractionSource: "agent-observed",
+      createdAt: ts,
+      lastSeenAt: ts,
+      navSuccesses: 0,
+      navFailures: 0,
+      attrs: { provisional: true, captureTime: true, anchorProvenance: "cite-confirmed", citeSessions: grown }
+    });
+    delete hints[fileId];
+    promoted = true;
+  } else {
+    hints[fileId] = grown;
+  }
+  store.updateNode(targetId, { attrs: { ...node2.attrs, citeAnchorHints: hints }, lastUpdatedAt: ts });
+  return { accrued: true, promoted };
+}
+function mintPriorEdge(store, source, target, sentence, touched, ts, sessionId) {
   if (target.id === source.id) return false;
   const type = typePriorEdge(source.label, target.label, sentence);
   const anchorIds = new Set(
@@ -53678,13 +54930,24 @@ function mintPriorEdge(store, source, target, sentence, touched, ts) {
     } catch {
     }
   }
-  return { corroborated };
+  let citeAnchorAccrued = false;
+  let citeAnchorPromoted = false;
+  if (!corroborated && sessionId && CITE_ANCHOR_LABELS.has(target.label)) {
+    try {
+      const acc = accrueCiteAnchor(store, target.id, touched, sessionId, ts);
+      citeAnchorAccrued = acc.accrued;
+      citeAnchorPromoted = acc.promoted;
+    } catch (err2) {
+      console.warn("[errata] cite-anchor accrual failed (citation kept):", err2 instanceof Error ? err2.message : err2);
+    }
+  }
+  return { corroborated, citeAnchorAccrued, citeAnchorPromoted };
 }
 function harvestInlineTags(store, text, opts) {
   const source = opts.sourceId ? store.getNode(opts.sourceId) : null;
   const mintPriors = opts.mintPriors ?? true;
   const touched = opts.sessionTouchedIds ?? /* @__PURE__ */ new Set();
-  const plan = { priorEdges: 0, corroboratedEdges: 0, exposureShown: 0, exposureEvicted: 0, exposureUnshown: 0, problems: [], fixes: [], triages: [], causalLinks: [], attempts: [], unresolvedFixes: [], unresolvedHandles: [], priorEdgesSuppressed: { flagOff: 0, noSource: 0 }, dispositions: emptyTagDispositions(), transfers: [], solutionLinks: [], instances: [], patterns: [], domains: [], packages: [], components: [], refutes: [], corroborations: [] };
+  const plan = { priorEdges: 0, corroboratedEdges: 0, citeAnchorsAccrued: 0, citeAnchorsPromoted: 0, exposureShown: 0, exposureEvicted: 0, exposureUnshown: 0, problems: [], fixes: [], triages: [], causalLinks: [], attempts: [], unresolvedFixes: [], unresolvedHandles: [], priorEdgesSuppressed: { flagOff: 0, noSource: 0 }, dispositions: emptyTagDispositions(), transfers: [], solutionLinks: [], instances: [], patterns: [], domains: [], packages: [], components: [], refutes: [], corroborations: [] };
   const parsed = parseInlineTagsWithDispositions(text);
   const tags = parsed.tags;
   plan.dispositions = parsed.dispositions;
@@ -53856,7 +55119,8 @@ function harvestInlineTags(store, text, opts) {
         if (nodeId) {
           const witnessKey = `refute:${nodeId}:${digest({ s: tag.statement ?? "" })}`.slice(0, 72);
           if (!plan.refutes.some((r) => r.witnessKey === witnessKey)) {
-            plan.refutes.push({ nodeId, witnessKey });
+            const reason = refuteReason(tag.statement);
+            plan.refutes.push({ nodeId, witnessKey, ...reason ? { reason } : {} });
           }
         }
       }
@@ -53891,7 +55155,8 @@ function harvestInlineTags(store, text, opts) {
         } else {
           const witnessKey = `refute:${targetId}:${digest({ s: tag.statement ?? "" })}`.slice(0, 72);
           if (!plan.refutes.some((r) => r.witnessKey === witnessKey)) {
-            plan.refutes.push({ nodeId: targetId, witnessKey });
+            const reason = refuteReason(tag.statement);
+            plan.refutes.push({ nodeId: targetId, witnessKey, ...reason ? { reason } : {} });
           }
         }
       }
@@ -53910,10 +55175,12 @@ function harvestInlineTags(store, text, opts) {
         }
       }
       if (mintPriors && source && target) {
-        const m = mintPriorEdge(store, source, target, tag.sentence, touched, opts.ts);
+        const m = mintPriorEdge(store, source, target, tag.sentence, touched, opts.ts, opts.sessionId);
         if (m) {
           plan.priorEdges++;
           if (m.corroborated) plan.corroboratedEdges++;
+          if (m.citeAnchorAccrued) plan.citeAnchorsAccrued++;
+          if (m.citeAnchorPromoted) plan.citeAnchorsPromoted++;
         }
       } else if (target) {
         if (!mintPriors) plan.priorEdgesSuppressed.flagOff++;
@@ -53923,10 +55190,12 @@ function harvestInlineTags(store, text, opts) {
       const targetId = resolveCited(tag.kind, tag.handle);
       const target = targetId ? store.getNode(targetId) : null;
       if (target) {
-        const m = mintPriorEdge(store, source, target, tag.sentence, touched, opts.ts);
+        const m = mintPriorEdge(store, source, target, tag.sentence, touched, opts.ts, opts.sessionId);
         if (m) {
           plan.priorEdges++;
           if (m.corroborated) plan.corroboratedEdges++;
+          if (m.citeAnchorAccrued) plan.citeAnchorsAccrued++;
+          if (m.citeAnchorPromoted) plan.citeAnchorsPromoted++;
         }
       }
     } else if (tag.handle) {
@@ -55751,7 +57020,7 @@ init_paths();
 init_src2();
 init_paths();
 import { existsSync as existsSync21, readFileSync as readFileSync20, writeFileSync as writeFileSync17 } from "node:fs";
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 import { join as join25 } from "node:path";
 
 // src/git-remote.ts
@@ -55808,11 +57077,11 @@ function detectRepoLocator(root, remote) {
 
 // src/profile.ts
 function workspaceId(root) {
-  return "wp_" + createHash13("sha256").update(root).digest("hex").slice(0, 12);
+  return "wp_" + createHash14("sha256").update(root).digest("hex").slice(0, 12);
 }
 function sessionOriginKey(sessionId) {
   if (!sessionId) return void 0;
-  return "ws_" + createHash13("sha256").update(sessionId).digest("hex").slice(0, 12);
+  return "ws_" + createHash14("sha256").update(sessionId).digest("hex").slice(0, 12);
 }
 function refreshRepoLocator(root, profile) {
   const detected = detectRepoLocator(root, profile.repoRemote);
@@ -56153,7 +57422,8 @@ var TITLES = {
   "hotspot-problem": "Errata \xB7 high-impact problem",
   "index-started": "Errata \xB7 indexing\u2026",
   "index-completed": "Errata \xB7 index ready \u2713",
-  "mechanism-stalled": "Errata \xB7 a mechanism is not working"
+  "mechanism-stalled": "Errata \xB7 a mechanism is not working",
+  "daemon-distress": "Errata \xB7 daemon health \u26A0"
 };
 var lastFired = /* @__PURE__ */ new Map();
 var THROTTLE_MS = 3e4;
@@ -56169,6 +57439,14 @@ function notifyEvent(kind, body2, opts = {}) {
   } catch {
   }
 }
+function notifyOpsEvent(kind, body2, opts = {}) {
+  try {
+    if (!loadConfig().opsNotices) return;
+  } catch {
+    return;
+  }
+  notifyEvent(kind, body2, opts);
+}
 function notifyTick(delta) {
   const { problemsResolved, reviewsTriggered } = delta;
   if (problemsResolved > 0)
@@ -56258,11 +57536,30 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/watch-census.ts
-var census = { dispatched: 0, emitted: 0, logged: 0, rejected: 0, since: Date.now() };
+var census = {
+  dispatched: 0,
+  emitted: 0,
+  logged: 0,
+  rejected: 0,
+  since: Date.now(),
+  breakerRecycles: 0,
+  breakerQuarantined: [],
+  topOffender: null
+};
+var QUARANTINE_LIST_CAP = 8;
 var noteWatchDispatched = () => void census.dispatched++;
 var noteWatchEmitted = () => void census.emitted++;
 var noteWatchLogged = () => void census.logged++;
 var noteWatchRejected = () => void census.rejected++;
+var noteBreakerRecycle = (_path) => void census.breakerRecycles++;
+var noteBreakerQuarantine = (path2) => {
+  if (!census.breakerQuarantined.includes(path2) && census.breakerQuarantined.length < QUARANTINE_LIST_CAP) {
+    census.breakerQuarantined.push(path2);
+  }
+};
+var noteWindowOffender = (path2, count, windowMs) => {
+  census.topOffender = { path: path2, count, windowMs, at: Date.now() };
+};
 function watchCensus() {
   return { ...census };
 }
@@ -56270,9 +57567,14 @@ function watchCensusLine(c = watchCensus()) {
   if (c.dispatched === 0 && c.emitted === 0) return null;
   const mins = Math.max(1, Math.round((Date.now() - c.since) / 6e4));
   const perMin = Math.round(c.dispatched / mins);
-  const base = `${c.dispatched} OS event(s) \u2192 ${c.logged} logged (${perMin}/min, ${c.rejected} rejected here)`;
-  if (c.logged === 0 && c.dispatched > 500) {
-    return `${base}  \u26A0 watcher is doing work with NO output \u2014 a watch target likely contains an ignored tree`;
+  let base = `${c.dispatched} OS event(s) \u2192 ${c.logged} logged (${perMin}/min, ${c.rejected} rejected here)`;
+  if (c.breakerRecycles > 0 || c.breakerQuarantined.length > 0) {
+    const q = c.breakerQuarantined.length > 0 ? `, ${c.breakerQuarantined.length} quarantined` : "";
+    base += ` \xB7 breaker: ${c.breakerRecycles} recycled${q}`;
+  }
+  if (c.dispatched > 500 && c.dispatched / Math.max(c.logged, 1) > 1e4) {
+    const top = c.topOffender ? ` \u2014 top: ${c.topOffender.path} (${c.topOffender.count}/${Math.round(c.topOffender.windowMs / 1e3)}s)` : "";
+    return `${base}  \u26A0 watcher is doing work with NO output \u2014 a watch target likely contains an ignored tree${top}`;
   }
   return base;
 }
@@ -56314,6 +57616,11 @@ function createLivenessWatch(deps) {
           watchEmitted: watch2.emitted,
           watchLogged: watch2.logged,
           watchRejected: watch2.rejected,
+          // HZ-watch-breaker: a recycle count trending upward across hours is a
+          // handle that keeps wedging — the restart-survivable trace the 8-16
+          // phantom-rename storm never left.
+          watchBreakerRecycles: watch2.breakerRecycles,
+          watchBreakerQuarantined: watch2.breakerQuarantined.length,
           // Concurrency and the longest single holder — the two readings that
           // named the 6017s zombie pass. A pass legitimately running for hours
           // and one wedged forever look identical without a trend.
@@ -56338,14 +57645,115 @@ function createLivenessWatch(deps) {
   };
 }
 
+// src/watch-breaker.ts
+function numEnv3(key, fallback) {
+  const n = Number(process.env[key]);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+var BREAKER_WINDOW_MS = numEnv3("ERRATA_WATCH_BREAKER_WINDOW_MS", 1e4);
+var BREAKER_TRIP_SELF_EVENTS = numEnv3("ERRATA_WATCH_BREAKER_TRIP", 1e3);
+var BREAKER_MAX_RECYCLES = numEnv3("ERRATA_WATCH_BREAKER_RECYCLES", 2);
+var BREAKER_REWEDGE_TTL_MS = numEnv3("ERRATA_WATCH_BREAKER_TTL_MS", 6e5);
+var BREAKER_READD_DELAY_MS = numEnv3("ERRATA_WATCH_BREAKER_READD_MS", 250);
+var OFFENDER_FLOOR = 100;
+function normalizeWatchPath(p) {
+  let s = p.startsWith("\\\\?\\") ? p.slice(4) : p;
+  s = s.replace(/\\/g, "/");
+  if (s.length > 1 && s.endsWith("/")) s = s.slice(0, -1);
+  return process.platform === "win32" ? s.toLowerCase() : s;
+}
+function createWatchBreaker(deps) {
+  const now = deps.now ?? Date.now;
+  const say = deps.onAction ?? (() => {
+  });
+  const windows2 = /* @__PURE__ */ new Map();
+  let windowStart = now();
+  const recycleHistory = /* @__PURE__ */ new Map();
+  const quarantined = /* @__PURE__ */ new Set();
+  const pendingReadds = /* @__PURE__ */ new Set();
+  const rotate = (t) => {
+    let top = null;
+    for (const [path2, w] of windows2) {
+      if (w.dispatched >= OFFENDER_FLOOR && (!top || w.dispatched > top.count)) {
+        top = { path: path2, count: w.dispatched };
+      }
+    }
+    if (top) noteWindowOffender(top.path, top.count, BREAKER_WINDOW_MS);
+    windows2.clear();
+    windowStart = t;
+  };
+  const trip = (path2, t) => {
+    const history = (recycleHistory.get(path2) ?? []).filter(
+      (ts) => t - ts < BREAKER_REWEDGE_TTL_MS
+    );
+    if (history.length >= BREAKER_MAX_RECYCLES) {
+      quarantined.add(path2);
+      recycleHistory.delete(path2);
+      try {
+        deps.unwatch(path2);
+      } catch {
+      }
+      noteBreakerQuarantine(path2);
+      say(
+        `QUARANTINED ${path2} \u2014 re-wedged after ${history.length} recycle(s); unwatched for this session (reconcile covers its edits)`
+      );
+      return;
+    }
+    history.push(t);
+    recycleHistory.set(path2, history);
+    try {
+      deps.unwatch(path2);
+    } catch {
+    }
+    const timer = setTimeout(() => {
+      pendingReadds.delete(timer);
+      try {
+        deps.readd(path2);
+      } catch {
+      }
+    }, BREAKER_READD_DELAY_MS);
+    timer.unref?.();
+    pendingReadds.add(timer);
+    noteBreakerRecycle(path2);
+    say(
+      `recycled ${path2} \u2014 ${BREAKER_TRIP_SELF_EVENTS}+ phantom self-events in ${Math.round(BREAKER_WINDOW_MS / 1e3)}s; handle closed + re-created`
+    );
+  };
+  return {
+    onRaw(event, evPath, watchedPath) {
+      if (typeof watchedPath !== "string" || watchedPath.length === 0) return;
+      const t = now();
+      if (t - windowStart >= BREAKER_WINDOW_MS) rotate(t);
+      let w = windows2.get(watchedPath);
+      if (!w) {
+        w = { dispatched: 0, self: 0, tripped: false };
+        windows2.set(watchedPath, w);
+      }
+      w.dispatched++;
+      const self = evPath == null || evPath === "" || typeof evPath === "string" && normalizeWatchPath(evPath) === normalizeWatchPath(watchedPath);
+      if (!self) return;
+      w.self++;
+      if (!w.tripped && !quarantined.has(watchedPath) && w.self >= BREAKER_TRIP_SELF_EVENTS) {
+        w.tripped = true;
+        trip(watchedPath, t);
+      }
+    },
+    stop() {
+      for (const timer of pendingReadds) clearTimeout(timer);
+      pendingReadds.clear();
+    }
+  };
+}
+
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.982" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2" : "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;
 var REINDEX_DEBOUNCE_MS = 200;
 var IDENTITY_AUDIT_MAX_BYTES = 16 * 1024 * 1024;
 var TURN_REPLAY_LOOKBACK_MS = 7 * 24 * 60 * 6e4;
+var CODEX_SWEEP_LOOKBACK_MS = 10 * 6e4;
 function appendIdentityAudit(path2, record2, line) {
   if (!record2.accepted && record2.score <= 0) return;
   try {
@@ -56470,6 +57878,7 @@ function createWorkspaceEngine(opts) {
   const cloud = opts.cloud;
   const telemetry = new TelemetryRecorder(profile.id, DAEMON_VERSION);
   let watcher = null;
+  let watchBreaker = null;
   let lastActivityTs = Date.now();
   let stopGit = null;
   let flushTimer = null;
@@ -56482,7 +57891,23 @@ function createWorkspaceEngine(opts) {
       ignoreInitial: true,
       persistent: true
     });
-    watcher.on("raw", noteWatchDispatched);
+    watchBreaker = createWatchBreaker({
+      unwatch: (p) => void watcher?.unwatch(p),
+      readd: (p) => void watcher?.add(p),
+      // Toast AND log: the autostarted daemon's stdout is a discarded stream
+      // (the 8-01 unobservability finding), so console alone would make every
+      // production breaker action invisible — the exact gauge-with-no-alarm
+      // shape this mechanism exists to end.
+      onAction: (line) => {
+        console.warn(`[errata] watch-breaker: ${line}`);
+        notifyOpsEvent("daemon-distress", `watch-breaker: ${line}`, { key: `breaker:${profile.id}` });
+      }
+    });
+    watcher.on("raw", (event, evPath, opts2) => {
+      noteWatchDispatched();
+      const watchedPath = opts2 && typeof opts2 === "object" && "watchedPath" in opts2 ? opts2.watchedPath : void 0;
+      watchBreaker?.onRaw(event, evPath, watchedPath);
+    });
     const onFs = (kind) => (path2) => {
       noteWatchEmitted();
       if (IGNORED_PATH.test(path2) || IGNORED_NOISE.test(path2)) {
@@ -56777,6 +58202,7 @@ function createWorkspaceEngine(opts) {
     }) : null;
     const doneRender = prebuilt ? null : markPass(`context-render-inline:${profile.name}`);
     const pendingUpdate = opts.pendingUpdate?.() ?? null;
+    const daemonDistress = opts.daemonDistress?.() ?? null;
     const reviewItems = pickReviewItems();
     const liveIntent = intents.mostRecent(Date.now());
     maybeRefreshIntentPriors(liveIntent ?? null);
@@ -56794,6 +58220,7 @@ function createWorkspaceEngine(opts) {
       ...elicit ? { edgeElicitation: { instruction: PRIOR_TAG_INSTRUCTION } } : {},
       ...prebuilt ? { snapshot: prebuilt } : {},
       ...pendingUpdate ? { pendingUpdate } : {},
+      ...daemonDistress ? { daemonDistress } : {},
       ...reviewItems.length ? { reviewItems } : {},
       ...liveIntent ? {
         statedIntent: {
@@ -56845,6 +58272,7 @@ function createWorkspaceEngine(opts) {
     contextDirty = false;
     notifyDigest("recall");
   };
+  const normStackTokens = (xs) => (xs ?? []).map((t) => t.trim().toLowerCase().replace(/(?!^)[@\s].*$/, "")).filter(Boolean);
   const maybeRefreshRemotePriors = () => {
     if (opts.skipContextWriter || remoteInFlight) return;
     const now = Date.now();
@@ -56855,10 +58283,13 @@ function createWorkspaceEngine(opts) {
     remoteInFlight = true;
     lastRemoteAt = now;
     try {
-      const norm = (xs) => (xs ?? []).map((t) => t.trim().toLowerCase().replace(/(?!^)[@\s].*$/, "")).filter(Boolean);
+      const norm = normStackTokens;
       const seed = store.findNodesByLabel("Problem").sort((a, b) => b.lastUpdatedAt - a.lastUpdatedAt).slice(0, 6).map((p) => p.id);
       const q = {
-        stack: norm(profile.stack),
+        // Languages ride the stack list: the cloud's context-affinity matcher
+        // resolves each token against both the Package and Language
+        // namespaces, and the profile keeps them in separate fields.
+        stack: norm([...profile.stack ?? [], ...profile.languages ?? []]),
         domains: norm(profile.domains),
         kinds: ["Pattern", "Technique", "AntiPattern"],
         ...seed.length ? { seed } : {},
@@ -56870,6 +58301,13 @@ function createWorkspaceEngine(opts) {
       };
       cloud.search(q).then((res) => {
         remotePriors = res.nodes ?? [];
+        const contributorLabels = [];
+        for (const n of remotePriors) {
+          const c = n.attrs?.["contributor"];
+          if (typeof c?.label === "string") contributorLabels.push(c.label);
+          if (typeof c?.team === "string") contributorLabels.push(c.team);
+        }
+        if (contributorLabels.length > 0) registerRenderedContributorLabels(contributorLabels);
         contextDirty = true;
       }).catch(() => {
       }).finally(() => {
@@ -56887,8 +58325,16 @@ function createWorkspaceEngine(opts) {
     if (typeof cloud.search !== "function") return;
     intentRemoteInFlight = true;
     cloud.search({
-      stack: [],
-      domains: [],
+      // VS-context-affinity: the intent lane used to send an empty context
+      // while the priming lane sent the profile — opposite postures on the
+      // same method. Under "union derived + stated, canonicalize once"
+      // (VS-intent-fence) the stated intent IS the query and the derived
+      // stack rides along as structured relevanceContext: the cloud no
+      // longer concatenates these tokens into the embedding string, it
+      // re-weights anchored hits with them (stated beats derived — the
+      // intent text drives entry search, the stack only re-ranks).
+      stack: normStackTokens([...profile?.stack ?? [], ...profile?.languages ?? []]),
+      domains: normStackTokens(profile?.domains ?? []),
       kinds: ["Pattern", "Technique", "AntiPattern", "Problem", "Solution"],
       q: liveIntent,
       channel: "intent",
@@ -57135,6 +58581,10 @@ function createWorkspaceEngine(opts) {
     let exposureEvicted = 0;
     let exposureUnshown = 0;
     let corroboratedEdges = 0;
+    let refutesStamped = 0;
+    let recurrencesMarked = 0;
+    let reopenedFromRegression = 0;
+    let fixHeldConfirmed = 0;
     const dispositions = emptyTagDispositions();
     let unresolvedHandles = 0;
     let priorEdgesFlagOff = 0;
@@ -57142,6 +58592,17 @@ function createWorkspaceEngine(opts) {
     let touchedFileTurns = 0;
     let touchedToolTurns = 0;
     let anchorHintsUpgraded = 0;
+    let foldAttempts = 0;
+    let foldNoFile = 0;
+    let foldNoCandidates = 0;
+    let foldKindVeto = 0;
+    let foldJaccardHit = 0;
+    let foldScoutHit = 0;
+    let foldNearMiss30 = 0;
+    let foldNearMiss45 = 0;
+    let foldCandidatesMarked = 0;
+    let citeAnchorsAccrued = 0;
+    let citeAnchorsPromoted = 0;
     let linked = 0;
     const t = Date.now();
     let processedTurns = 0;
@@ -57193,11 +58654,25 @@ function createWorkspaceEngine(opts) {
           const r = ingestDesignProblem(store, flag, {
             workspaceId: profile.id,
             source: sessionId,
-            ts: t
+            ts: t,
+            hostHarness: turn.hostHarness
           });
           if (r.created || r.corroborated) minted++;
           else if (r.rejected) tagsRejected++;
           else tagsRestated++;
+          if (r.recurredResolved) {
+            recurrencesMarked++;
+            if (r.reopenedFromRegression) {
+              reopenedFromRegression++;
+              console.warn(
+                `[errata] REOPENED from regression: ${r.problemId} \u2014 second independent witness; the fix did not hold`
+              );
+            } else {
+              console.warn(
+                `[errata] REGRESSION candidate: a resolved problem recurred (${r.problemId}) \u2014 marked resolutionSuspect, not reopened`
+              );
+            }
+          }
           if (flag.kind !== "constraint") sessionLastProblem.set(sessionId, designProblemId(flag.problem));
           if (r.created || r.corroborated) {
             try {
@@ -57271,10 +58746,42 @@ function createWorkspaceEngine(opts) {
           handleMap,
           ts: t,
           mintPriors: elicit,
+          // WM-fold phase 3: cite-time anchor accrual keys on the session — two
+          // DISTINCT sessions co-citing a prior from the same file promote a
+          // real anchor; one session, or none, accrues silently.
+          sessionId,
           ...touched.size > 0 ? { sessionTouchedIds: touched } : {}
         });
         priorEdges += plan.priorEdges;
         corroboratedEdges += plan.corroboratedEdges;
+        citeAnchorsAccrued += plan.citeAnchorsAccrued;
+        citeAnchorsPromoted += plan.citeAnchorsPromoted;
+        const refuteResult = applyLocalRefutations(store, plan.refutes, t);
+        refutesStamped += refuteResult.stamped;
+        for (const c of plan.corroborations) {
+          const node2 = store.getNode(c.nodeId);
+          if (node2?.label !== "Solution") continue;
+          const held = confirmFixHeld(store, c.nodeId, t);
+          if (held > 0) {
+            fixHeldConfirmed += held;
+            console.log(`[errata] fix-held confirmed: ${node2.id} \u2014 ${held} regression question(s) acknowledged`);
+          }
+        }
+        for (const id of refuteResult.stampedIds) {
+          const node2 = store.getNode(id);
+          if (node2?.label !== "Solution") continue;
+          for (const e of store.inEdges(id, ["SOLVED_BY", "FIXED_BY"])) {
+            const touch = markResolvedRecurrence(store, e.from, t, sessionId);
+            if (!touch.marked) continue;
+            recurrencesMarked++;
+            if (touch.reopened) {
+              reopenedFromRegression++;
+              console.warn(
+                `[errata] REOPENED from regression: ${e.from} \u2014 its solution ${id} was refuted by a second independent witness`
+              );
+            }
+          }
+        }
         addTagDispositions(dispositions, plan.dispositions);
         unresolvedHandles += plan.unresolvedHandles.length;
         priorEdgesFlagOff += plan.priorEdgesSuppressed.flagOff;
@@ -57294,26 +58801,93 @@ function createWorkspaceEngine(opts) {
           const anchorProvenance = p.location?.path ? "witnessed" : "edited";
           const hintPath = anchorPath ? void 0 : turnFile ?? wf;
           const dedupPath = anchorPath ?? hintPath;
+          let pendingNomination = null;
           if (dedupPath) {
             try {
-              const dupId = reinforceSameAnchorProblem(store, dedupPath, profile.id, p.statement, sessionId, t, p.kind);
-              if (dupId) {
+              foldAttempts++;
+              const fold = foldSameAnchorProblem(store, dedupPath, profile.id, p.statement, sessionId, t, p.kind);
+              if (fold.noFile) foldNoFile++;
+              else if (fold.candidates === 0) foldNoCandidates++;
+              foldKindVeto += fold.kindVetoed;
+              if (!fold.foldedId) {
+                if (fold.bestJaccard >= 0.45) foldNearMiss45++;
+                else if (fold.bestJaccard >= 0.3) foldNearMiss30++;
+                if (fold.nominate) {
+                  pendingNomination = { ...fold.nominate, source: "file-scout" };
+                }
+              }
+              if (fold.foldedId) {
+                if (fold.foldedBy === "scout") foldScoutHit++;
+                else foldJaccardHit++;
                 minted++;
                 if (p.kind !== "constraint") {
-                  sessionLastProblem.set(sessionId, dupId);
-                  inScopeProblemId = dupId;
+                  sessionLastProblem.set(sessionId, fold.foldedId);
+                  inScopeProblemId = fold.foldedId;
                 }
-                if (p.threadId) threads.set(p.threadId, dupId);
+                if (p.threadId) threads.set(p.threadId, fold.foldedId);
                 continue;
               }
             } catch {
             }
           }
+          if (!pendingNomination) {
+            try {
+              const ws = findWorkspaceFoldCandidate(store, profile.id, p.statement, p.kind);
+              if (ws) pendingNomination = { ...ws, source: "workspace-scout" };
+            } catch (err2) {
+              console.warn("[errata] workspace fold scout failed (mint unaffected):", err2 instanceof Error ? err2.message : err2);
+            }
+          }
           const r = ingestDesignProblem(store, { problem: p.statement, kind: p.kind }, {
             workspaceId: profile.id,
             source: sessionId,
-            ts: t
+            ts: t,
+            hostHarness: turn.hostHarness
           });
+          if (r.created && dedupPath) {
+            try {
+              const closedId = findResolvedAnchorMatch(store, dedupPath, profile.id, p.statement, p.kind);
+              const touch = closedId ? markResolvedRecurrence(store, closedId, t, sessionId) : { marked: false, reopened: false };
+              if (closedId && touch.marked) {
+                store.mergeEdge({
+                  id: `edge_${digest({ from: r.problemId, type: "REGRESSION_OF", to: closedId })}`.slice(0, 24),
+                  from: r.problemId,
+                  to: closedId,
+                  type: "REGRESSION_OF",
+                  confidence: 0.5,
+                  extractionSource: "daemon-extracted",
+                  createdAt: t,
+                  lastSeenAt: t,
+                  navSuccesses: 0,
+                  navFailures: 0,
+                  attrs: { provisional: true, machineProposed: true, session: sessionId }
+                });
+                recurrencesMarked++;
+                if (touch.reopened) reopenedFromRegression++;
+                console.warn(
+                  `[errata] REGRESSION candidate: new problem ${r.problemId} paraphrases resolved ${closedId} on ${dedupPath} \u2014 bound REGRESSION_OF, marked resolutionSuspect` + (touch.reopened ? "; second independent witness \u2014 REOPENED" : "")
+                );
+              }
+            } catch (err2) {
+              console.warn(
+                "[errata] regression recognition failed (mint unaffected):",
+                err2 instanceof Error ? err2.message : err2
+              );
+            }
+          }
+          if (r.created && pendingNomination) {
+            try {
+              const marked = markFoldCandidate(store, r.problemId, pendingNomination.targetId, {
+                ...pendingNomination.hashCos !== void 0 ? { hashCos: pendingNomination.hashCos } : {},
+                ...pendingNomination.jaccard !== void 0 ? { jaccard: pendingNomination.jaccard } : {},
+                source: pendingNomination.source,
+                ts: t
+              });
+              if (marked) foldCandidatesMarked++;
+            } catch (err2) {
+              console.warn("[errata] fold nomination failed (mint unaffected):", err2 instanceof Error ? err2.message : err2);
+            }
+          }
           if (r.created || r.corroborated) {
             minted++;
             if (p.kind !== "constraint") {
@@ -57649,7 +59223,7 @@ function createWorkspaceEngine(opts) {
         if (typeof cloud.reportContradictions === "function") {
           await sendWitnesses(
             "contradict",
-            plan.refutes,
+            wireWitnessItems(plan.refutes),
             (items2, session) => cloud.reportContradictions({
               daemonVersion: DAEMON_VERSION,
               projectId: profile.id,
@@ -57717,6 +59291,15 @@ function createWorkspaceEngine(opts) {
         triaged,
         priorEdges,
         corroboratedEdges,
+        // RG-mark: refute witnesses stamped onto local nodes (the local half of
+        // the contradict channel; the wire half rides the witness ledger).
+        refutesStamped,
+        // RG-recognize tier A: resolved problems the door saw recur this pass.
+        recurrencesMarked,
+        // RG-reopen: closes flipped open on the two-touch evidence bar.
+        reopenedFromRegression,
+        // RG-prime: regression questions acknowledged by a fix-held confirm.
+        fixHeldConfirmed,
         // WM-labels calibration cells (see prior-tags exposure split).
         exposureShown,
         exposureEvicted,
@@ -57726,6 +59309,20 @@ function createWorkspaceEngine(opts) {
         exposureOutcomes: exposureShown + exposureEvicted + exposureUnshown,
         // AC-hint-upgrade (harvest seam): edited-this-turn hint promotions.
         anchorHintsUpgraded,
+        // WM-fold funnel (phase 0) — which gate of the same-anchor fold
+        // conjunction eats the mass, and the near-miss bands under the bars.
+        foldAttempts,
+        foldNoFile,
+        foldNoCandidates,
+        foldKindVeto,
+        foldJaccardHit,
+        foldScoutHit,
+        foldNearMiss30,
+        foldNearMiss45,
+        foldCandidatesMarked,
+        // WM-fold phase 3 — cite-time anchor accrual on cited priors.
+        citeAnchorsAccrued,
+        citeAnchorsPromoted,
         touchedFileTurns,
         touchedToolTurns,
         // Seam diagnostic: sessions holding tool-run records at harvest time.
@@ -57850,11 +59447,70 @@ function createWorkspaceEngine(opts) {
           await yieldToLoop();
           await harvestSession(ref.sessionId, ref.path);
         }
+        const codexRefs = codexRolloutsForCwd(opts.workspaceRoot, {
+          sinceMs: Date.now() - TURN_REPLAY_LOOKBACK_MS,
+          limit: 25
+        });
+        for (const ref of codexRefs) {
+          await yieldToLoop();
+          await harvestSession(ref.sessionId, ref.path);
+        }
+        const geminiRefs = geminiTranscriptsForCwd(opts.workspaceRoot, {
+          sinceMs: Date.now() - TURN_REPLAY_LOOKBACK_MS,
+          limit: 25
+        });
+        for (const ref of geminiRefs) {
+          await yieldToLoop();
+          await harvestSession(ref.sessionId, ref.path);
+        }
+        const opencodeRefs = opencodeTranscriptsForCwd(opts.workspaceRoot, {
+          sinceMs: Date.now() - TURN_REPLAY_LOOKBACK_MS,
+          limit: 25
+        });
+        for (const ref of opencodeRefs) {
+          await yieldToLoop();
+          await harvestSession(ref.sessionId, ref.path);
+        }
       } catch {
       }
     })();
   });
+  const sweepCodexRollouts = () => {
+    setImmediate(() => {
+      void (async () => {
+        try {
+          const since = Date.now() - CODEX_SWEEP_LOOKBACK_MS;
+          const refs = [
+            ...codexRolloutsForCwd(opts.workspaceRoot, { sinceMs: since, limit: 10 }),
+            ...geminiTranscriptsForCwd(opts.workspaceRoot, { sinceMs: since, limit: 10 }),
+            ...opencodeTranscriptsForCwd(opts.workspaceRoot, { sinceMs: since, limit: 10 })
+          ];
+          for (const ref of refs) {
+            await yieldToLoop();
+            await harvestSession(ref.sessionId, ref.path);
+          }
+        } catch {
+        }
+      })();
+    });
+  };
   const designRollup = opts.designRollup ?? (process.env["ERRATA_ROLLUP"] === "1" ? haikuDesignRollup(process.env["ANTHROPIC_API_KEY"] ?? null) : void 0);
+  const foldJudgeModel = process.env["ERRATA_FOLD_JUDGE_MODEL"] ?? "gpt-5-mini";
+  const foldJudge = process.env["ERRATA_FOLD_JUDGE"] === "1" && isChatConfigured(foldJudgeModel) ? async (a, b) => {
+    const out2 = await chat({
+      model: foldJudgeModel,
+      system: "You judge whether two independently-written one-line problem reports from the same codebase describe the SAME underlying problem. Reworded restatements of one problem are SAME; related-but-different defects, or a defect vs a design constraint, are DISTINCT. Answer with exactly one word: SAME or DISTINCT.",
+      user: `A: ${a}
+B: ${b}`,
+      maxTokens: 8
+    });
+    if (!out2) return null;
+    const same = /\bSAME\b/i.test(out2);
+    const distinct = /\bDISTINCT\b/i.test(out2);
+    if (same && !distinct) return "same";
+    if (distinct && !same) return "distinct";
+    return null;
+  } : void 0;
   const onSessionEnd = (e) => {
     if (!designRollup) return;
     setImmediate(() => {
@@ -57992,6 +59648,7 @@ function createWorkspaceEngine(opts) {
       refreshContextNow();
     },
     async tick() {
+      sweepCodexRollouts();
       maybeRefreshRemotePriors();
       const report = {
         generalizerEventsProcessed: 0,
@@ -58130,16 +59787,49 @@ function createWorkspaceEngine(opts) {
         const sem = await embedSemanticNodes(store);
         if (sem.embedded > 0) {
           console.log(`[errata] embedded ${sem.embedded} semantic node(s)`);
-          const e = mergeProblemsByEmbedding(store, { ts: Date.now() });
-          if (e.merged > 0) {
-            console.log(`[errata] dedup: merged ${e.merged} paraphrased problem(s) by embedding across ${e.clusters} cluster(s)`);
-          }
+        }
+        const parkWmRaw = store.getMeta?.("fold_park_sweep_at") ?? null;
+        const e = mergeProblemsByEmbedding(store, {
+          ts: Date.now(),
+          ...parkWmRaw !== null ? { freshSince: Number(parkWmRaw) || 0 } : {}
+        });
+        store.setMeta?.("fold_park_sweep_at", String(Date.now()));
+        if (e.merged > 0 || (e.nearMissMarked ?? 0) > 0) {
+          console.log(`[errata] dedup: merged ${e.merged} paraphrased problem(s) across ${e.clusters} cluster(s), parked ${e.nearMissMarked ?? 0} near-miss nomination(s)${parkWmRaw === null ? " (first full sweep)" : ""}`);
+        }
+        if (sem.embedded > 0) {
           const cb = bindCanonicalNeighbors(store, { ts: Date.now() });
           if (cb.bound > 0) {
             console.log(`[errata] canonical-bind: +${cb.bound} machine-proposed link(s) across ${cb.scanned} problem(s)`);
           }
           refreshContextNow();
         }
+        const rg = bindResolvedRegressions(store, { ts: Date.now() });
+        if (rg.bound > 0) {
+          console.warn(`[errata] REGRESSION: bound ${rg.bound} open problem(s) to resolved predecessors${rg.full ? " (first full sweep)" : ""}`);
+          refreshContextNow();
+        }
+        const fjStart = Date.now();
+        const fj = await resolveFoldCandidates(store, {
+          ts: fjStart,
+          ...foldJudge ? { judge: foldJudge } : {}
+        });
+        if (fj.examined > 0) {
+          appendPassLedger(paths.configDir, "fold-judge", Date.now() - fjStart, {
+            examined: fj.examined,
+            folded: fj.folded,
+            foldedEmbedding: fj.foldedEmbedding,
+            foldedJudge: fj.foldedJudge,
+            rejected: fj.rejected,
+            standing: fj.standing,
+            judgeErrors: fj.judgeErrors,
+            retargeted: fj.retargeted
+          });
+          if (fj.folded > 0) {
+            console.log(`[errata] fold-judge: folded ${fj.folded} paraphrase pair(s) (${fj.foldedEmbedding} by embedding, ${fj.foldedJudge} by judge), ${fj.standing} standing`);
+            refreshContextNow();
+          }
+        }
         return { embedded: sem.embedded };
       } catch (err2) {
         console.warn("[errata] settled embed failed:", err2);
@@ -58174,6 +59864,10 @@ function createWorkspaceEngine(opts) {
             console.log(`[errata] dedup: merged ${e.merged} paraphrased problem(s) by embedding across ${e.clusters} cluster(s)`);
             refreshContextNow();
           }
+          const rg = bindResolvedRegressions(store, { ts: Date.now() });
+          if (rg.bound > 0) {
+            console.warn(`[errata] REGRESSION: bound ${rg.bound} open problem(s) to resolved predecessors${rg.full ? " (first full sweep)" : ""}`);
+          }
           const cb = bindCanonicalNeighbors(store, { ts: Date.now() });
           if (cb.bound > 0) {
             console.log(`[errata] canonical-bind: +${cb.bound} machine-proposed link(s) across ${cb.scanned} problem(s)`);
@@ -58264,6 +59958,7 @@ function createWorkspaceEngine(opts) {
     async stop() {
       if (stopGit) stopGit();
       if (passWorker) await passWorker.stop();
+      if (watchBreaker) watchBreaker.stop();
       if (watcher) await watcher.close();
       if (flushTimer) clearTimeout(flushTimer);
       for (const tmr of diagTimers.values()) clearTimeout(tmr);
@@ -59633,6 +61328,157 @@ function createRootAdopter(deps) {
   };
 }
 
+// src/health-sentinel.ts
+function numEnv4(key, fallback) {
+  const n = Number(process.env[key]);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+var SENTINEL_TICK_MS = numEnv4("ERRATA_SENTINEL_TICK_MS", 3e4);
+var SENTINEL_WINDOW_TICKS = numEnv4("ERRATA_SENTINEL_WINDOW_TICKS", 6);
+var SENTINEL_BURN_CORES = numEnv4("ERRATA_SENTINEL_BURN_CORES", 1.2);
+var SENTINEL_STORM_RATE = numEnv4("ERRATA_SENTINEL_STORM_RATE", 1e3);
+var SENTINEL_STORM_TICKS = numEnv4("ERRATA_SENTINEL_STORM_TICKS", 4);
+var SENTINEL_RENOTIFY_MS = numEnv4("ERRATA_SENTINEL_RENOTIFY_MS", 18e5);
+var SENTINEL_CALM_TICKS = numEnv4("ERRATA_SENTINEL_CALM_TICKS", 2);
+var SENTINEL_TOAST_COOLDOWN_MS = numEnv4("ERRATA_SENTINEL_TOAST_COOLDOWN_MS", 6e5);
+function createHealthSentinel(deps = {}) {
+  const now = deps.now ?? Date.now;
+  const cpuUsage = deps.cpuUsage ?? (() => process.cpuUsage());
+  const readCensus = deps.readCensus ?? (() => {
+    const c = watchCensus();
+    return {
+      dispatched: c.dispatched,
+      logged: c.logged,
+      topOffender: c.topOffender ? { path: c.topOffender.path, count: c.topOffender.count } : null
+    };
+  });
+  const activePasses = deps.activePasses ?? (() => passState().active.map((p) => p.name));
+  const rssMb = deps.rssMb ?? (() => Math.round(process.memoryUsage.rss() / 1048576));
+  const toast = deps.notify ?? ((body2, key) => notifyOpsEvent("daemon-distress", body2, { key }));
+  let prevCpu = cpuUsage();
+  let prevTs = now();
+  let prevDispatched = null;
+  let prevLogged = 0;
+  const coreSamples = [];
+  let stormTicks = 0;
+  let calmTicks = 0;
+  let distress = null;
+  let lastNotifiedAt = 0;
+  const lastToastByKind = /* @__PURE__ */ new Map();
+  const attribution = () => {
+    const parts2 = [];
+    const passes = activePasses();
+    if (passes.length > 0) parts2.push(`active pass: ${passes.join(", ")}`);
+    const c = readCensus();
+    if (c.topOffender) parts2.push(`hottest watch path: ${c.topOffender.path}`);
+    parts2.push(`rss ${rssMb()}MB`);
+    return parts2.join(" \xB7 ");
+  };
+  const maybeToast = (d, t) => {
+    if (t - (lastToastByKind.get(d.kind) ?? 0) < SENTINEL_TOAST_COOLDOWN_MS) return;
+    lastToastByKind.set(d.kind, t);
+    toast(d.headline, d.kind);
+    lastNotifiedAt = t;
+  };
+  const transition = (next) => {
+    const t = now();
+    if (next && !distress) {
+      distress = next;
+      deps.ledger?.("enter", next);
+      maybeToast(next, t);
+      deps.onChange?.(next);
+    } else if (next && distress) {
+      distress.body = next.body;
+      distress.headline = next.headline;
+      if (t - lastNotifiedAt >= SENTINEL_RENOTIFY_MS) maybeToast(distress, t);
+    } else if (!next && distress) {
+      deps.ledger?.("clear", distress);
+      distress = null;
+      deps.onChange?.(null);
+    }
+  };
+  const evaluate = () => {
+    const t = now();
+    const wallMs = Math.max(1, t - prevTs);
+    const cpu = cpuUsage();
+    const cores = (cpu.user + cpu.system - prevCpu.user - prevCpu.system) / 1e3 / wallMs;
+    prevCpu = cpu;
+    prevTs = t;
+    coreSamples.push(cores);
+    if (coreSamples.length > SENTINEL_WINDOW_TICKS) coreSamples.shift();
+    const c = readCensus();
+    const dispatchRate = prevDispatched === null ? 0 : (c.dispatched - prevDispatched) / wallMs * 1e3;
+    const survived = c.logged - prevLogged;
+    prevDispatched = c.dispatched;
+    prevLogged = c.logged;
+    stormTicks = dispatchRate > SENTINEL_STORM_RATE && survived === 0 ? stormTicks + 1 : 0;
+    let wanted = null;
+    if (stormTicks >= SENTINEL_STORM_TICKS) {
+      wanted = {
+        kind: "watch-storm",
+        headline: `errata's file watcher is stuck busy (~${Math.round(dispatchRate)} events/sec with nothing changing) \u2014 run \`errata status\` for detail`,
+        body: `filesystem watcher is processing ~${Math.round(dispatchRate)} events/sec with NOTHING surviving \u2014 a wedged or ignored-tree watch is burning CPU for no signal \xB7 ${attribution()}`,
+        sinceTs: distress?.kind === "watch-storm" ? distress.sinceTs : t
+      };
+    } else {
+      const windowFull = coreSamples.length >= SENTINEL_WINDOW_TICKS;
+      const avgCores = coreSamples.reduce((a, b) => a + b, 0) / Math.max(1, coreSamples.length);
+      if (windowFull && avgCores >= SENTINEL_BURN_CORES && cores >= SENTINEL_BURN_CORES && activePasses().length === 0) {
+        wanted = {
+          kind: "cpu-burn",
+          headline: `errata is using more CPU than expected (${avgCores.toFixed(1)} cores with no work running) \u2014 run \`errata status\` for detail`,
+          body: `sustained CPU with no pass running \u2014 avg ${avgCores.toFixed(1)} cores \xB7 ${attribution()}`,
+          sinceTs: distress?.kind === "cpu-burn" ? distress.sinceTs : t
+        };
+      }
+    }
+    if (wanted) {
+      calmTicks = 0;
+      transition(wanted);
+    } else if (distress) {
+      calmTicks++;
+      if (calmTicks >= SENTINEL_CALM_TICKS) {
+        calmTicks = 0;
+        transition(null);
+      }
+    }
+  };
+  const interval = deps.scheduleTicks === false ? null : setInterval(() => {
+    try {
+      evaluate();
+    } catch {
+    }
+  }, SENTINEL_TICK_MS);
+  interval?.unref?.();
+  return {
+    current: () => distress ? { ...distress } : null,
+    tick: evaluate,
+    stop: () => {
+      if (interval) clearInterval(interval);
+    }
+  };
+}
+
+// src/codex-wake.ts
+var CODEX_WAKE_LOOKBACK_MS = 10 * 6e4;
+var CODEX_WAKE_BOOT_LOOKBACK_MS = 24 * 60 * 6e4;
+function codexWakeCandidates(input) {
+  if (input.disabled) return [];
+  const find = input.find ?? ((cwd, since) => codexRolloutsForCwd(cwd, { sinceMs: since, limit: 1 }).length + geminiTranscriptsForCwd(cwd, { sinceMs: since, limit: 1 }).length + opencodeTranscriptsForCwd(cwd, { sinceMs: since, limit: 1 }).length);
+  const out2 = [];
+  for (const entry of input.entries) {
+    if (input.liveRoots.has(input.normPath(entry.path))) continue;
+    let n = 0;
+    try {
+      n = find(entry.path, input.sinceMs);
+    } catch {
+      continue;
+    }
+    if (n > 0) out2.push({ name: entry.name, path: entry.path });
+  }
+  return out2;
+}
+
 // src/multi.ts
 var projectSymbolSalts = /* @__PURE__ */ new Map();
 async function resolveProjectSymbolSalt(client, projectId) {
@@ -59777,9 +61623,24 @@ async function startMultiDaemon(opts = {}) {
       for (const r of records) r.engine.markContextDirty();
     }
   }) : null;
+  const healthSentinel = createHealthSentinel({
+    onChange: () => {
+      for (const r of records) r.engine.markContextDirty();
+    },
+    ledger: (event, d) => {
+      const dir = records[0]?.engine.paths.configDir;
+      if (dir) {
+        appendPassLedger(dir, "health-sentinel", 0, {
+          [`distress:${event}:${d.kind}`]: 1,
+          distressSinceTs: d.sinceTs
+        });
+      }
+    }
+  });
   let serverPending = null;
   const boundaryListeners = [];
   let boundaryFlushing = false;
+  let settleRunning = false;
   let boundaryFlushStartedAt = 0;
   let boundaryFlushStage = "";
   let boundaryFlushUnits = 0;
@@ -59871,6 +61732,10 @@ async function startMultiDaemon(opts = {}) {
       reviewUrl: () => `${baseUrl}/ws/${id}/review`,
       sharedStore,
       pendingUpdate: () => serverPending ?? updatePoller?.current() ?? null,
+      // Ops-gated (default OFF): the 🚨 notice reads as "errata broke my
+      // machine" to a non-operator. Detection + ledger run regardless — only
+      // this push surface (and the toast, gated in notifyOpsEvent) is scoped.
+      daemonDistress: () => loadConfig().opsNotices ? healthSentinel.current() : null,
       ...opts.skipWatchers ? { skipWatchers: true } : {}
     });
     const webApp = buildWebUi({
@@ -59959,7 +61824,7 @@ async function startMultiDaemon(opts = {}) {
       registerWorkspace(rec.engine.profile, rec.root);
     } catch {
     }
-    void rec.engine.reindex({ skipEmbed: true }).catch(() => {
+    void rec.engine.reindex({ skipEmbed: true, quiet: rec.engine.store.nodeCount() > 0 }).catch(() => {
     });
     console.log(`[errata] hot-registered ${rec.entry.name} (${rec.id}) \u2014 now watching live`);
     return { attached: true, id: rec.id };
@@ -60155,6 +62020,33 @@ async function startMultiDaemon(opts = {}) {
   };
   const idleSweep = setInterval(sweepIdleWorkspaces, WORKSPACE_SWEEP_INTERVAL_MS);
   idleSweep.unref?.();
+  let codexWakeFirstPass = true;
+  const sweepCodexWake = () => {
+    const lookback = codexWakeFirstPass ? CODEX_WAKE_BOOT_LOOKBACK_MS : CODEX_WAKE_LOOKBACK_MS;
+    codexWakeFirstPass = false;
+    let entries2;
+    try {
+      entries2 = listWorkspaceEntries();
+    } catch {
+      return;
+    }
+    const candidates = codexWakeCandidates({
+      entries: entries2,
+      liveRoots: new Set(records.map((r) => normPath(r.root))),
+      normPath,
+      sinceMs: Date.now() - lookback,
+      disabled: process.env["ERRATA_CODEX_WAKE_DISABLE"] === "1"
+    });
+    for (const c of candidates) {
+      if (attachWorkspace(c.path).attached) {
+        console.log(`[errata] woke workspace ${c.name} \u2014 recent Codex/Gemini/OpenCode transcript (headless capture)`);
+      }
+    }
+  };
+  const codexWake = setInterval(sweepCodexWake, WORKSPACE_SWEEP_INTERVAL_MS);
+  codexWake.unref?.();
+  const codexWakeBoot = setTimeout(sweepCodexWake, 5e3);
+  codexWakeBoot.unref?.();
   const reindexAll = async (rOpts) => {
     const out2 = /* @__PURE__ */ new Map();
     const toIndex = records.filter((r) => rOpts?.force || r.engine.store.nodeCount() === 0);
@@ -60843,12 +62735,19 @@ async function startMultiDaemon(opts = {}) {
       return { written, pruned: pruned2 };
     },
     async sessionBoundaryFlush() {
+      if (!settleRunning) {
+        settleRunning = true;
+        try {
+          for (const r of records) {
+            await r.engine.embedSettled();
+          }
+        } finally {
+          settleRunning = false;
+        }
+      }
       if (boundaryFlushing) return { uploaded: 0, written: 0, pruned: 0, skipped: "in-flight" };
-      beginFlush("embed");
+      beginFlush("instances");
       try {
-        for (const r of records) {
-          await r.engine.embedSettled();
-        }
         flushStage("instances");
         const inst = await daemon.syncInstancesPublic();
         flushStage("skills");
@@ -60868,6 +62767,8 @@ async function startMultiDaemon(opts = {}) {
     },
     async stop() {
       clearInterval(idleSweep);
+      clearInterval(codexWake);
+      clearTimeout(codexWakeBoot);
       try {
         const cur = readFileSync27(lockPath, "utf8");
         if (JSON.parse(cur).pid === process.pid) unlinkSync3(lockPath);
@@ -60877,6 +62778,7 @@ async function startMultiDaemon(opts = {}) {
         (res) => server.close(res)
       );
       updatePoller?.stop();
+      healthSentinel.stop();
       for (const r of records) await r.engine.stop();
       if (consolidateWorker) await consolidateWorker.stop();
       try {
@@ -61501,6 +63403,17 @@ function shouldUseOAuthLogin(flags2, env2 = process.env) {
 }
 
 // src/doctor.ts
+import { spawnSync } from "node:child_process";
+function installedHarnessVersion(bin) {
+  try {
+    const r = spawnSync(bin, ["--version"], { encoding: "utf8", timeout: 3e3 });
+    if (r.status !== 0 && !r.stdout) return null;
+    const m = /(\d+\.\d+\.\d+)/.exec(`${r.stdout ?? ""}${r.stderr ?? ""}`);
+    return m ? m[1] : null;
+  } catch {
+    return null;
+  }
+}
 async function diagnoseInstallation(cfg, dependencies) {
   const checks = [];
   const profileName = cfg.activeInstallationProfile;
@@ -61573,6 +63486,20 @@ async function diagnoseInstallation(cfg, dependencies) {
       });
     }
   }
+  const versionOf = dependencies.harnessVersion ?? installedHarnessVersion;
+  for (const { bin, pinned } of [
+    { bin: "codex", pinned: CODEX_PARSER_PINNED_VERSION },
+    { bin: "opencode", pinned: OPENCODE_PARSER_PINNED_VERSION }
+  ]) {
+    const installed = versionOf(bin);
+    checks.push(
+      installed === null ? { id: `${bin}_parser_pin`, status: "pass", detail: `${bin} not installed \u2014 parser-pin check skipped` } : installed === pinned ? { id: `${bin}_parser_pin`, status: "pass", detail: `${bin} ${installed} matches the transcript-parser pin` } : {
+        id: `${bin}_parser_pin`,
+        status: "warn",
+        detail: `${bin} ${installed} \u2260 parser pinned ${pinned} \u2014 transcripts verified against ${pinned}; re-pin fixtures if capture drifts`
+      }
+    );
+  }
   return {
     ok: checks.every((check2) => check2.status !== "fail"),
     profile: profileName,
@@ -61632,7 +63559,7 @@ var DEFAULT_CONSOLIDATION_POLICY = {
   quiescenceMs: 6e4
   // sim preferred 60s over 90s (fresher, esp. heavy-code)
 };
-function numEnv3(env2, key, fallback) {
+function numEnv5(env2, key, fallback) {
   const raw2 = env2[key];
   if (raw2 == null || raw2.trim() === "") return fallback;
   const n = Number(raw2);
@@ -61640,18 +63567,196 @@ function numEnv3(env2, key, fallback) {
 }
 function consolidationPolicyFromEnv(env2 = process.env) {
   return {
-    baseFloorMs: numEnv3(env2, "ERRATA_CONSOLIDATE_BASE_FLOOR_MS", DEFAULT_CONSOLIDATION_POLICY.baseFloorMs),
-    dutyFactor: numEnv3(env2, "ERRATA_CONSOLIDATE_DUTY_FACTOR", DEFAULT_CONSOLIDATION_POLICY.dutyFactor),
-    momentumThreshold: numEnv3(env2, "ERRATA_CONSOLIDATE_MOMENTUM", DEFAULT_CONSOLIDATION_POLICY.momentumThreshold),
-    momentumRatio: numEnv3(env2, "ERRATA_CONSOLIDATE_MOMENTUM_RATIO", DEFAULT_CONSOLIDATION_POLICY.momentumRatio),
-    momentumRatioCap: numEnv3(env2, "ERRATA_CONSOLIDATE_MOMENTUM_RATIO_CAP", DEFAULT_CONSOLIDATION_POLICY.momentumRatioCap),
-    quiescenceMs: numEnv3(env2, "ERRATA_CONSOLIDATE_QUIESCENCE_MS", DEFAULT_CONSOLIDATION_POLICY.quiescenceMs)
+    baseFloorMs: numEnv5(env2, "ERRATA_CONSOLIDATE_BASE_FLOOR_MS", DEFAULT_CONSOLIDATION_POLICY.baseFloorMs),
+    dutyFactor: numEnv5(env2, "ERRATA_CONSOLIDATE_DUTY_FACTOR", DEFAULT_CONSOLIDATION_POLICY.dutyFactor),
+    momentumThreshold: numEnv5(env2, "ERRATA_CONSOLIDATE_MOMENTUM", DEFAULT_CONSOLIDATION_POLICY.momentumThreshold),
+    momentumRatio: numEnv5(env2, "ERRATA_CONSOLIDATE_MOMENTUM_RATIO", DEFAULT_CONSOLIDATION_POLICY.momentumRatio),
+    momentumRatioCap: numEnv5(env2, "ERRATA_CONSOLIDATE_MOMENTUM_RATIO_CAP", DEFAULT_CONSOLIDATION_POLICY.momentumRatioCap),
+    quiescenceMs: numEnv5(env2, "ERRATA_CONSOLIDATE_QUIESCENCE_MS", DEFAULT_CONSOLIDATION_POLICY.quiescenceMs)
   };
 }
 function consolidationGapMs(lastPassMs, policy) {
   return Math.max(policy.baseFloorMs, lastPassMs * policy.dutyFactor);
 }
 
+// src/hook-commands.ts
+function hookCurlCommand(port, path2 = "/api/hook") {
+  const url2 = `http://127.0.0.1:${port}${path2}`;
+  return process.platform === "win32" ? `cmd //c "curl -s --connect-timeout 1 --max-time 3 -X POST -H \\"Content-Type: application/json\\" --data-binary @- ${url2} >NUL 2>NUL || exit /b 0"` : `curl -s --connect-timeout 1 --max-time 3 -X POST -H 'Content-Type: application/json' --data-binary @- ${url2} >/dev/null 2>&1 || true`;
+}
+function hookRelayCommand(port, path2) {
+  const url2 = `http://127.0.0.1:${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 '{}'`;
+}
+var CODEX_HOOKS_BEGIN = `# >>> errata hooks (errata-managed)`;
+var CODEX_HOOKS_END = `# <<< errata hooks`;
+function buildCodexHooksToml(port) {
+  const cmd2 = hookCurlCommand(port).replace(/"/g, '\\"');
+  const turnCmd = hookCurlCommand(port, "/api/turn").replace(/"/g, '\\"');
+  return `${CODEX_HOOKS_BEGIN}
+[[hooks.PreToolUse]]
+matcher = ".*"
+
+[[hooks.PreToolUse.hooks]]
+type = "command"
+command = "${cmd2}"
+timeout = 10
+
+[[hooks.PostToolUse]]
+matcher = ".*"
+
+[[hooks.PostToolUse.hooks]]
+type = "command"
+command = "${cmd2}"
+timeout = 10
+
+[[hooks.PostToolUse.hooks]]
+type = "command"
+command = "${turnCmd}"
+timeout = 10
+${CODEX_HOOKS_END}
+`;
+}
+
+// src/opencode-plugin.ts
+var OPENCODE_PLUGIN_MARKER = "// @inerrata opencode plugin \u2014 errata-managed (errata install-hooks opencode)";
+var OPENCODE_D1_CONTRACT = "Behavioral contract: (1) On ANY error, call search() BEFORE debugging \u2014 costs ~400 tokens vs 5,000\u201350,000 cold. (2) After solving non-trivial problems, contribute back: if your harness emits typed nodes (canonicalId + label + attrs), use ingest \u2014 the typed door; otherwise call contribute(), the prose fallback. (3) Before web search, try search() first \u2014 graph is 2\u201315\xD7 cheaper. (4) At session end, review what you solved and contribute anything novel.";
+var OPENCODE_TOOL_FAILURE_NUDGE = "[inerrata] This tool call failed \u2014 call search() with the error message BEFORE debugging from scratch (~400 tokens vs 5,000\u201350,000 cold).";
+function buildOpencodePluginSource(port, opts = {}) {
+  const version2 = opts.version ?? "dev";
+  return `${OPENCODE_PLUGIN_MARKER}
+// Generated by errata ${version2}. Re-run \`errata install-hooks opencode\` to update; edits here are overwritten.
+// What it does: mirrors each OpenCode session's OWN message record to a JSONL
+// file the errata daemon can parse, and tells the daemon on every turn boundary.
+// It has no dependencies and never throws into OpenCode.
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const DAEMON = "http://127.0.0.1:${port}";
+const HEADER_TYPE = "errata-opencode-session";
+const D1_CONTRACT = ${JSON.stringify(OPENCODE_D1_CONTRACT)};
+const TOOL_FAILURE_NUDGE = ${JSON.stringify(OPENCODE_TOOL_FAILURE_NUDGE)};
+
+function mirrorRoot() {
+  const explicit = process.env.ERRATA_OPENCODE_SESSIONS_DIRS;
+  if (explicit) { const first = explicit.split(":").map((s) => s.trim()).find(Boolean); if (first) return first; }
+  if (process.env.XDG_DATA_HOME) return join(process.env.XDG_DATA_HOME, "opencode", "errata");
+  return join(homedir(), ".local", "share", "opencode", "errata");
+}
+
+async function post(path, body) {
+  try {
+    const res = await fetch(DAEMON + path, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body), signal: AbortSignal.timeout(15000) });
+    return res.status;
+  } catch { return 0; }
+}
+
+export const InerrataPlugin = async (input) => {
+  const directory = input.directory;
+  const projectID = input.project && input.project.id ? input.project.id : null;
+  const root = mirrorRoot();
+  // per-session state: which message ids are already in the mirror file
+  const written = new Map(); // sessionID -> Set<messageId>
+  const files = new Map();   // sessionID -> path
+
+  function fileFor(sessionID) {
+    let p = files.get(sessionID);
+    if (p) return p;
+    try { mkdirSync(root, { recursive: true }); } catch {}
+    p = join(root, sessionID + ".jsonl");
+    files.set(sessionID, p);
+    const seen = new Set();
+    if (existsSync(p)) {
+      // resumed session / plugin re-instantiated: learn what is already mirrored
+      try {
+        for (const line of readFileSync(p, "utf8").split("\\n")) {
+          if (!line) continue;
+          try { const o = JSON.parse(line); if (o && o.info && typeof o.info.id === "string") seen.add(o.info.id); } catch {}
+        }
+      } catch {}
+    } else {
+      appendFileSync(p, JSON.stringify({ type: HEADER_TYPE, version: 1, sessionID, directory, projectID, worktree: input.worktree || null, writtenAt: Date.now() }) + "\\n");
+    }
+    written.set(sessionID, seen);
+    return p;
+  }
+
+  async function mirror(sessionID) {
+    // OpenCode's own record: session.messages() items are {info: Message, parts: Part[]}
+    // (the same objects \`opencode export\` prints). Append only completed assistant
+    // messages + every user message not yet mirrored; ids never repeat.
+    const p = fileFor(sessionID);
+    const seen = written.get(sessionID);
+    let items = [];
+    try {
+      const r = await input.client.session.messages({ path: { id: sessionID } });
+      items = (r && r.data) ? r.data : (Array.isArray(r) ? r : []);
+    } catch { return { path: p, appended: 0 }; }
+    let appended = 0;
+    for (const item of items) {
+      const info = item && item.info;
+      if (!info || typeof info.id !== "string" || seen.has(info.id)) continue;
+      if (info.role === "assistant" && !(info.time && info.time.completed)) continue; // still streaming
+      try {
+        appendFileSync(p, JSON.stringify({ info, parts: Array.isArray(item.parts) ? item.parts : [] }) + "\\n");
+        seen.add(info.id); appended++;
+      } catch {}
+    }
+    return { path: p, appended };
+  }
+
+  const touched = new Set();
+  return {
+    // D1's text reaches OpenCode (\xA711.5 item 1): appended to the SYSTEM prompt
+    // of every request \u2014 the same channel the Claude session-start hook uses
+    // (system-level fires reliably; per-turn nudges measurably do not).
+    // \`experimental.chat.system.transform\` is the hook the 1.18.18 plugin
+    // API exposes for this ({sessionID?, model} \u2192 {system: string[]}).
+    "experimental.chat.system.transform": async (_input, output) => {
+      try {
+        if (output && Array.isArray(output.system) && !output.system.includes(D1_CONTRACT)) output.system.push(D1_CONTRACT);
+      } catch {}
+    },
+    // Tool-failure nudge (\xA711.5 item 2): when a tool result looks failed, one
+    // advisory line is appended to the OUTPUT the model reads. Failure is a
+    // heuristic \u2014 \`metadata\` is untyped in the plugin API \u2014 pinned to the
+    // shapes observed: metadata.error truthy, or a non-zero exit/exitCode.
+    "tool.execute.after": async (_input, output) => {
+      try {
+        if (!output || typeof output.output !== "string") return;
+        const meta = output.metadata;
+        const failed = !!(meta && (meta.error || (typeof meta.exit === "number" && meta.exit !== 0) || (typeof meta.exitCode === "number" && meta.exitCode !== 0)));
+        if (failed && !output.output.includes(TOOL_FAILURE_NUDGE)) output.output = output.output + "\\n\\n" + TOOL_FAILURE_NUDGE;
+      } catch {}
+    },
+    event: async ({ event }) => {
+      try {
+        if (!event || typeof event.type !== "string") return;
+        const sid = event.properties && event.properties.sessionID;
+        if (event.type === "session.created" && sid) { fileFor(sid); touched.add(sid); return; }
+        if (event.type === "session.idle" && sid) {
+          const { path, appended } = await mirror(sid);
+          touched.add(sid);
+          // turn boundary \u2192 the daemon harvests the mirror (idempotent per turn)
+          await post("/api/turn", { session_id: "opencode:" + sid, transcript_path: path, cwd: directory, hostHarness: "opencode", appended });
+        }
+      } catch {}
+    },
+    dispose: async () => {
+      // OpenCode has no session-end event; process disposal is the closest.
+      for (const sid of touched) {
+        try {
+          const { path } = await mirror(sid);
+          await post("/api/session-end", { session_id: "opencode:" + sid, transcript_path: path, cwd: directory, reason: "opencode-dispose" });
+        } catch {}
+      }
+    },
+  };
+};
+`;
+}
+
 // src/cli.ts
 var exitCleanOnEpipe = (err2) => {
   if (err2.code === "EPIPE") process.exit(0);
@@ -61733,7 +63838,7 @@ async function main() {
     case "install-hooks":
       return cmdInstallHooks(rest);
     case "mcp":
-      return cmdMcp();
+      return cmdMcp(rest);
     case "sync":
       return cmdSync(rest[0] ?? "now");
     case "feedback":
@@ -61744,6 +63849,8 @@ async function main() {
       return cmdConsent(rest);
     case "notifications":
       return cmdNotifications(rest[0] ?? "");
+    case "ops-notices":
+      return cmdOpsNotices(rest[0] ?? "");
     case "update":
       return cmdUpdate(rest);
     case "projects":
@@ -61832,10 +63939,11 @@ Commands:
                       Written to .errata/report.html. Flag: --future-verbs
   install-hooks <harness>
                       Wire harness hooks \u2192 daemon /api/hook (or MCP).
-                      <harness>: claude (default) | cursor | codex | aider
+                      <harness>: claude (default) | cursor | codex | opencode | aider
                       Flags: --port N (default 7891)
-  mcp                 Run the MCP stdio server \u2014 the agent's full errata tool
-                      surface (navigation, problems, claims, burst, health)
+  mcp [--grok]        Run the MCP stdio server \u2014 the agent's full errata tool
+                      surface (navigation, problems, claims, burst, health).
+                      --grok emits bare tool names accepted by Grok Code.
   login               Sign in with the cloud. Default: short verification URL +
                       typeable code (device-bridged OAuth). Flags: --browser
                       (loopback code flow) \xB7 --token <key> \xB7
@@ -61867,6 +63975,9 @@ Commands:
                       Send scrubbed feedback to the maintainers (needs login)
   notifications <on|off>
                       Desktop toasts on problem open/resolve + review ready
+  ops-notices <on|off>
+                      Ops-grade health surfaces (daemon-distress toast + agent
+                      notice). Default off; for people operating errata itself
 
 Environment:
   ERRATA_CLOUD_URL                Cloud base URL (default ${DEFAULT_CLOUD_URL})
@@ -63660,19 +65771,22 @@ async function cmdStop() {
     }
   }
 }
-async function cmdMcp() {
+async function cmdMcp(args2) {
   await ensureProfile();
-  ensureSingletonRunning();
+  const grokCompatibility = args2.includes("--grok");
+  ensureSingletonRunning({ withoutPinnedConfig: grokCompatibility });
   const { runMcpServer: runMcpServer2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
-  await runMcpServer2(ROOT);
+  await runMcpServer2(ROOT, { toolNameStyle: grokCompatibility ? "bare" : "prefixed" });
 }
 function selfArgv(sub) {
   const self = process.execPath;
   if (/errata(\.exe)?$/i.test(self)) return { cmd: self, args: [sub] };
   return { cmd: self, args: [...process.execArgv, process.argv[1] ?? "", sub] };
 }
-function spawnDaemonDetached() {
+function spawnDaemonDetached(options = {}) {
   const { cmd: cmd2, args: args2 } = selfArgv("dash");
+  const daemonEnv = { ...process.env };
+  if (options.withoutPinnedConfig) delete daemonEnv["ERRATA_CONFIG_PATH"];
   let out2 = "ignore";
   try {
     const logPath = daemonLogPath();
@@ -63694,20 +65808,20 @@ function spawnDaemonDetached() {
     // a backstop, not a working limit. NODE_OPTIONS so it applies however the
     // bundle re-executes.
     env: {
-      ...process.env,
-      NODE_OPTIONS: `${process.env["NODE_OPTIONS"] ?? ""} --max-old-space-size=${DAEMON_MAX_HEAP_MB}`.trim()
+      ...daemonEnv,
+      NODE_OPTIONS: `${daemonEnv["NODE_OPTIONS"] ?? ""} --max-old-space-size=${DAEMON_MAX_HEAP_MB}`.trim()
     }
   }).unref();
   if (out2 !== "ignore") closeSync2(out2);
 }
-function ensureSingletonRunning() {
+function ensureSingletonRunning(options = {}) {
   try {
     if (isDaemonAlive(globalDaemonLock())) return true;
-    spawnDaemonDetached();
+    spawnDaemonDetached(options);
     void (async () => {
       if (await waitForDaemon(globalDaemonLock(), 8e3)) return;
       if (isDaemonAlive(globalDaemonLock())) return;
-      spawnDaemonDetached();
+      spawnDaemonDetached(options);
       await waitForDaemon(globalDaemonLock(), 8e3);
     })();
     return true;
@@ -63729,28 +65843,66 @@ async function cmdInstallHooks(args2) {
     case "codex":
       await installCodexHooks(port);
       return;
+    case "opencode":
+      await installOpencodePlugin(port);
+      return;
     case "aider":
       printAiderInstructions();
       return;
     default:
       console.error(`unknown harness: ${harness}`);
-      console.error(`  supported: claude, cursor, codex, aider`);
+      console.error(`  supported: claude, cursor, codex, opencode, aider`);
       process.exit(2);
   }
 }
+async function installOpencodePlugin(port) {
+  const { mkdirSync: mkdirSync9, existsSync: existsSync31, readFileSync: readFileSync29, writeFileSync: writeFileSync23 } = await import("node:fs");
+  const { join: join33 } = await import("node:path");
+  const dir = join33(ROOT, ".opencode", "plugin");
+  if (!existsSync31(dir)) mkdirSync9(dir, { recursive: true });
+  const file2 = join33(dir, "inerrata.js");
+  if (existsSync31(file2)) {
+    const head2 = readFileSync29(file2, "utf8").split("\n")[0] ?? "";
+    if (head2.trim() !== OPENCODE_PLUGIN_MARKER) {
+      console.error(`refusing to overwrite ${file2}: not an errata-managed plugin (line 1 lacks the marker)`);
+      process.exit(2);
+    }
+  }
+  writeFileSync23(file2, buildOpencodePluginSource(port, { version: DAEMON_VERSION }), "utf8");
+  const cfgFile = join33(ROOT, "opencode.json");
+  let cfg = { $schema: "https://opencode.ai/config.json" };
+  if (existsSync31(cfgFile)) {
+    try {
+      cfg = JSON.parse(readFileSync29(cfgFile, "utf8"));
+    } catch {
+      console.error(`refusing to touch invalid JSON at ${cfgFile} \u2014 fix it and re-run`);
+      process.exit(2);
+    }
+  }
+  cfg.mcp ??= {};
+  const hadErrata = "errata" in cfg.mcp;
+  if (!hadErrata) {
+    const inv = errataMcpInvocation();
+    cfg.mcp["errata"] = { type: "local", command: [inv.command, ...inv.args] };
+    writeFileSync23(cfgFile, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  }
+  console.log(`installed OpenCode plugin \u2192 ${file2}`);
+  if (hadErrata) console.log(`  mcp.errata already present in ${cfgFile} \u2014 left untouched`);
+  else console.log(`installed OpenCode MCP server config \u2192 ${cfgFile} (mcp.errata: local \`errata mcp\`)`);
+  console.log(`  endpoint: http://127.0.0.1:${port}/api/turn on every session.idle (+ /api/session-end on dispose)`);
+  console.log("");
+  console.log(`  OpenCode keeps sessions in SQLite, so the plugin mirrors each session's`);
+  console.log(`  own message record to $XDG_DATA_HOME/opencode/errata/<sessionID>.jsonl`);
+  console.log(`  (override: ERRATA_OPENCODE_SESSIONS_DIRS) and the daemon parses THAT \u2014`);
+  console.log(`  role-typed, attested. Works for headless \`opencode run\` too.`);
+  console.log(`  Cloud tools (search/contribute) are the MCP entry in opencode.json:`);
+  console.log(`    { "mcp": { "inerrata": { "type": "remote", "url": "https://mcp.inerrata.dev/mcp", "headers": { "Authorization": "Bearer <errk_\u2026>" } } } }`);
+}
 var ERRATA_TAG = "# errata-managed";
 function errataMcpInvocation() {
   const { cmd: cmd2, args: args2 } = selfArgv("mcp");
   return { command: cmd2, args: args2 };
 }
-function hookCurlCommand(port, path2 = "/api/hook") {
-  const url2 = `http://127.0.0.1:${port}${path2}`;
-  return process.platform === "win32" ? `cmd //c "curl -s --connect-timeout 1 --max-time 3 -X POST -H \\"Content-Type: application/json\\" --data-binary @- ${url2} >NUL 2>NUL || exit /b 0"` : `curl -s --connect-timeout 1 --max-time 3 -X POST -H 'Content-Type: application/json' --data-binary @- ${url2} >/dev/null 2>&1 || true`;
-}
-function hookRelayCommand(port, path2) {
-  const url2 = `http://127.0.0.1:${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: mkdirSync9, existsSync: existsSync31, readFileSync: readFileSync29, writeFileSync: writeFileSync23 } = await import("node:fs");
   const { join: join33 } = await import("node:path");
@@ -63872,45 +66024,32 @@ async function installCodexHooks(port) {
   const dir = join33(ROOT, ".codex");
   if (!existsSync31(dir)) mkdirSync9(dir, { recursive: true });
   const file2 = join33(dir, "config.toml");
-  const BEGIN = `# >>> errata hooks (errata-managed)`;
-  const END = `# <<< errata hooks`;
   let existing = "";
   if (existsSync31(file2)) {
     existing = readFileSync29(file2, "utf8");
-    const beginIdx = existing.indexOf(BEGIN);
-    const endIdx = existing.indexOf(END);
+    const beginIdx = existing.indexOf(CODEX_HOOKS_BEGIN);
+    const endIdx = existing.indexOf(CODEX_HOOKS_END);
     if (beginIdx >= 0 && endIdx > beginIdx) {
-      existing = existing.slice(0, beginIdx).trimEnd() + existing.slice(endIdx + END.length).trimStart();
+      existing = existing.slice(0, beginIdx).trimEnd() + existing.slice(endIdx + CODEX_HOOKS_END.length).trimStart();
     }
   }
-  const cmd2 = hookCurlCommand(port).replace(/"/g, '\\"');
-  const block = `${BEGIN}
-[[hooks.PreToolUse]]
-matcher = ".*"
-
-[[hooks.PreToolUse.hooks]]
-type = "command"
-command = "${cmd2}"
-timeout = 10
-
-[[hooks.PostToolUse]]
-matcher = ".*"
-
-[[hooks.PostToolUse.hooks]]
-type = "command"
-command = "${cmd2}"
-timeout = 10
-${END}
-`;
+  const block = buildCodexHooksToml(port);
   const final = existing.length > 0 && !existing.endsWith("\n") ? `${existing}
 
 ${block}` : existing + (existing.endsWith("\n\n") ? "" : "\n") + block;
   writeFileSync23(file2, final, "utf8");
   console.log(`installed Codex hooks \u2192 ${file2}`);
-  console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
+  console.log(`  endpoint: http://127.0.0.1:${port}/api/hook (+ /api/turn on PostToolUse)`);
   console.log("");
   console.log(`  Codex reads files via the shell, so the virtual graph surface`);
   console.log(`  works by \`cat .errata/g/<verb>/<seed>\` (e.g. cat .errata/g/burst/foo).`);
+  console.log("");
+  console.log(`  Codex has no Stop/SessionEnd hook at this installed version, so`);
+  console.log(`  [!\u2026]/(fix:[\u2026]) tags are harvested via the PostToolUse-triggered`);
+  console.log(`  /api/turn call above instead \u2014 every turn with a tool call is`);
+  console.log(`  covered; a tool-less final turn is picked up on this workspace's`);
+  console.log(`  next daemon boot replay. Re-run this after a Codex upgrade in`);
+  console.log(`  case a newer version adds a real turn-boundary hook.`);
   console.log(`  If [features] hooks=false in your config.toml, set it true. Hook`);
   console.log(`  schemas evolve \u2014 if hooks stop firing after an update, re-run this.`);
 }
@@ -64413,6 +66552,19 @@ async function cmdNotifications(state) {
   saveConfig(cfg);
   console.log(`desktop notifications ${cfg.notifications ? "enabled" : "disabled"}`);
 }
+async function cmdOpsNotices(state) {
+  const s = state.toLowerCase();
+  if (s !== "on" && s !== "off") {
+    console.error("usage: errata ops-notices <on|off>");
+    process.exit(2);
+  }
+  const cfg = loadConfig();
+  cfg.opsNotices = s === "on";
+  saveConfig(cfg);
+  console.log(
+    `ops health notices ${cfg.opsNotices ? "enabled \u2014 distress conditions will toast and reach the agent context" : "disabled \u2014 detection and `errata status` still run"}`
+  );
+}
 async function cmdFeedback(args2) {
   const cfg = loadConfig();
   if (!hasCloudCredential(cfg)) {