@inerrata-corporation/errata 2.0.2-dev.1172 → 2.0.2-dev.1182

package/consolidate-worker.mjs

@@ -201,7 +201,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"];
@@ -336,6 +336,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,
@@ -15862,7 +15863,13 @@ var LOCAL_RULE_OVERRIDES = {
   // 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"] }
 };
 function localEdgeViolation(fromLabel, type, toLabel) {
   if (type in LOCAL_RULE_OVERRIDES) {
@@ -16849,6 +16856,9 @@ init_src2();
 init_src();
 init_src();
 
+// ../../packages/local-graph/src/design-problem.ts
+var RECURRENCE_DEBOUNCE_MS = 60 * 60 * 1e3;
+
 // ../../packages/local-graph/src/intent.ts
 init_src();
 

package/errata.mjs

@@ -278,7 +278,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"];
@@ -343,8 +343,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
@@ -457,6 +459,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,
@@ -16720,7 +16723,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 = `
@@ -19121,7 +19130,17 @@ function ingestDesignProblem(store, flag, opts) {
   const existing = store.getNode(problemId);
   let created = false;
   let corroborated = false;
+  let recurredResolved = false;
   if (existing) {
+    const resolvedUnretracted = existing.attrs["resolvedAt"] != null && existing.attrs["resolvedAs"] == null;
+    const recurAttrs = () => {
+      recurredResolved = true;
+      return {
+        resolutionSuspect: true,
+        recurredAt: opts.ts,
+        recurrences: (Number(existing.attrs["recurrences"]) || 0) + 1
+      };
+    };
     const sources = existing.attrs["sources"] ?? [];
     if (!sources.includes(opts.source)) {
       corroborated = true;
@@ -19130,6 +19149,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 } : {},
@@ -19155,6 +19177,11 @@ function ingestDesignProblem(store, flag, opts) {
         ...reinforcedSeqAttrs(store, existing.label),
         lastUpdatedAt: 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
+      });
     }
   } else {
     created = true;
@@ -19210,7 +19237,16 @@ 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 } : {}
+  };
 }
 function canonicalizePatternText(name2) {
   const stripped = name2.replace(/^\s*pattern(?:\s*[×x]\s*\d+)?\s*(?:\(exemplar\))?\s*[:—–-]\s*/i, "").replace(/\s+/g, " ").trim();
@@ -19395,6 +19431,43 @@ function reinforceSameAnchorProblem(store, relPath, workspaceId2, statement, sou
   }
   return existing.id;
 }
+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 markResolvedRecurrence(store, nodeId, ts) {
+  const n = store.getNode(nodeId);
+  if (!n) return false;
+  if (n.attrs["resolvedAt"] == null || n.attrs["resolvedAs"] != null) return false;
+  store.updateNode(nodeId, {
+    attrs: {
+      ...n.attrs,
+      resolutionSuspect: true,
+      recurredAt: ts,
+      recurrences: (Number(n.attrs["recurrences"]) || 0) + 1
+    },
+    lastUpdatedAt: ts
+  });
+  return true;
+}
 function isFragmentFixNote(note) {
   const t = note.trim();
   if (t.length === 0) return true;
@@ -19796,7 +19869,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, 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";
@@ -19809,6 +19882,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([
@@ -22375,6 +22449,19 @@ var init_mechanism_liveness = __esm({
         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: "fix-candidate-ask",
         what: "asks an agent whether an edit to a problem's anchor fixed it",
@@ -22634,6 +22721,7 @@ __export(src_exports2, {
   PERCOLATING_DRIFT_EDGES: () => PERCOLATING_DRIFT_EDGES,
   PERCOLATING_EDGES: () => PERCOLATING_EDGES,
   PERCOLATING_LABELS: () => PERCOLATING_LABELS,
+  RECURRENCE_DEBOUNCE_MS: () => RECURRENCE_DEBOUNCE_MS,
   SAME_ANCHOR_DEDUP_JACCARD: () => SAME_ANCHOR_DEDUP_JACCARD,
   STALL_MIN_RUNS: () => STALL_MIN_RUNS,
   STALL_MIN_SPAN_MS: () => STALL_MIN_SPAN_MS,
@@ -22676,6 +22764,7 @@ __export(src_exports2, {
   findMintTimeDuplicate: () => findMintTimeDuplicate,
   findOrCreatePackage: () => findOrCreatePackage,
   findPath: () => findPath,
+  findResolvedAnchorMatch: () => findResolvedAnchorMatch,
   findReusableSolution: () => findReusableSolution,
   flattenCloudCounts: () => flattenCloudCounts,
   foldDuplicateProblem: () => foldDuplicateProblem,
@@ -22698,6 +22787,7 @@ __export(src_exports2, {
   localEdgeViolation: () => localEdgeViolation,
   markDiscriminatorAsked: () => markDiscriminatorAsked,
   markFixCandidates: () => markFixCandidates,
+  markResolvedRecurrence: () => markResolvedRecurrence,
   markRevisit: () => markRevisit,
   matchLanguagesInText: () => matchLanguagesInText,
   matchPackagesInText: () => matchPackagesInText,
@@ -29418,6 +29508,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)) 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;
@@ -30899,6 +31033,7 @@ __export(src_exports4, {
   annotateResolution: () => annotateResolution,
   attributeRootCause: () => attributeRootCause,
   bindCanonicalNeighbors: () => bindCanonicalNeighbors,
+  bindResolvedRegressions: () => bindResolvedRegressions,
   closeProblem: () => closeProblem,
   codeAnchorProjection: () => codeAnchorProjection,
   commandSignature: () => commandSignature,
@@ -56818,7 +56953,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.1172" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.1182" : "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;
@@ -57654,6 +57789,7 @@ function createWorkspaceEngine(opts) {
     let exposureUnshown = 0;
     let corroboratedEdges = 0;
     let refutesStamped = 0;
+    let recurrencesMarked = 0;
     const dispositions = emptyTagDispositions();
     let unresolvedHandles = 0;
     let priorEdgesFlagOff = 0;
@@ -57718,6 +57854,12 @@ function createWorkspaceEngine(opts) {
           if (r.created || r.corroborated) minted++;
           else if (r.rejected) tagsRejected++;
           else tagsRestated++;
+          if (r.recurredResolved) {
+            recurrencesMarked++;
+            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 {
@@ -57836,6 +57978,35 @@ function createWorkspaceEngine(opts) {
             ts: t,
             hostHarness: turn.hostHarness
           });
+          if (r.created && dedupPath) {
+            try {
+              const closedId = findResolvedAnchorMatch(store, dedupPath, profile.id, p.statement, p.kind);
+              if (closedId && markResolvedRecurrence(store, closedId, t)) {
+                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++;
+                console.warn(
+                  `[errata] REGRESSION candidate: new problem ${r.problemId} paraphrases resolved ${closedId} on ${dedupPath} \u2014 bound REGRESSION_OF, marked resolutionSuspect`
+                );
+              }
+            } catch (err2) {
+              console.warn(
+                "[errata] regression recognition failed (mint unaffected):",
+                err2 instanceof Error ? err2.message : err2
+              );
+            }
+          }
           if (r.created || r.corroborated) {
             minted++;
             if (p.kind !== "constraint") {
@@ -58242,6 +58413,8 @@ function createWorkspaceEngine(opts) {
         // 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,
         // WM-labels calibration cells (see prior-tags exposure split).
         exposureShown,
         exposureEvicted,
@@ -58691,6 +58864,11 @@ function createWorkspaceEngine(opts) {
           }
           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();
+        }
         return { embedded: sem.embedded };
       } catch (err2) {
         console.warn("[errata] settled embed failed:", err2);
@@ -58725,6 +58903,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)`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.2-dev.1172",
+  "version": "2.0.2-dev.1182",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {

package/pass-worker.mjs

@@ -212,7 +212,7 @@ var init_castalia = __esm({
     DECOMPOSITION_EDGES = ["SPLIT_INTO"];
     TRANSFER_EDGES = ["MAY_RESOLVE"];
     SOLUTION_STRUCTURE_EDGES = ["BUILDS_ON", "SUPERSEDES", "ALTERNATIVE_TO"];
-    SUSPICION_EDGES = ["SUSPECTED_LINK"];
+    SUSPICION_EDGES = ["SUSPECTED_LINK", "REGRESSION_OF"];
     TAXONOMY_EDGES = ["IS_A"];
     TRIAGE_EDGES = ["TRIAGED_BY", "CONFIRMS", "INDICATES", "ROUTES_TO"];
     GIT_EDGES = ["POINTS_AT", "PARENT", "AUTHORED_BY"];
@@ -277,8 +277,10 @@ var init_castalia = __esm({
       "ALTERNATIVE_TO",
       // symmetric peer marker — weight would let alternatives inflate each other
       // NB: BUILDS_ON is NOT excluded — it flows extension→base so foundational solutions rank up.
-      "SUSPECTED_LINK"
+      "SUSPECTED_LINK",
       // Somnus hypothesis (PLAN_SOMNUS_V2 §4) — never flows rank; navigation-invisible.
+      "REGRESSION_OF"
+      // recurrence marker (RG-recognize) — a question about a close, not signal-flow.
     ]);
     EDGE_WEIGHT = {
       // Causal — high signal
@@ -391,6 +393,7 @@ var init_castalia = __esm({
       ALTERNATIVE_TO: 0,
       // Suspicion — a hypothesis, weightless + PageRank-excluded (never flows rank / EIG).
       SUSPECTED_LINK: 0,
+      REGRESSION_OF: 0,
       // Git — topology/authorship, weightless (not domain signal-flow)
       POINTS_AT: 0,
       PARENT: 0,
@@ -24296,7 +24299,13 @@ var LOCAL_RULE_OVERRIDES = {
   // 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"] }
 };
 function localEdgeViolation(fromLabel, type, toLabel) {
   if (type in LOCAL_RULE_OVERRIDES) {
@@ -25758,6 +25767,7 @@ function foldDuplicateProblem(store2, dup, survivor, ts) {
 function isConstraintProblem(node) {
   return node.attrs["kind"] === "constraint";
 }
+var RECURRENCE_DEBOUNCE_MS = 60 * 60 * 1e3;
 var CITABLE_PRIOR_LABELS = /* @__PURE__ */ new Set([
   "Solution",
   "RootCause",