@inerrata-corporation/errata 2.0.0-dev.20 → 2.0.0-dev.22

package/consolidate-worker.mjs

@@ -15847,11 +15847,26 @@ function recordTriageObservation(l2, obs, ts) {
     const perContext = {
       ...existing?.attrs["perContext"] ?? {}
     };
+    const inferred = obs.evidence === "inferred";
     for (const b of buckets) {
       const cur = perContext[b] ?? { confirmed: 0, contributors: [] };
       const contribs = new Set(cur.contributors ?? []);
-      if (obs.contributor) contribs.add(obs.contributor);
-      perContext[b] = { confirmed: cur.confirmed + 1, contributors: [...contribs] };
+      const inferredContribs = new Set(cur.inferredContributors ?? []);
+      if (obs.contributor) {
+        if (inferred) {
+          if (!contribs.has(obs.contributor)) inferredContribs.add(obs.contributor);
+        } else {
+          inferredContribs.delete(obs.contributor);
+        }
+        contribs.add(obs.contributor);
+      }
+      perContext[b] = {
+        ...cur,
+        confirmed: cur.confirmed + 1,
+        contributors: [...contribs],
+        ...inferredContribs.size > 0 ? { inferredContributors: [...inferredContribs] } : {}
+      };
+      if (inferredContribs.size === 0) delete perContext[b].inferredContributors;
     }
     const discriminator = obs.discriminator ?? existing?.attrs["discriminator"];
     const attrs = {

package/errata.mjs

@@ -18795,11 +18795,26 @@ function recordTriageObservation(l2, obs, ts) {
     const perContext = {
       ...existing?.attrs["perContext"] ?? {}
     };
+    const inferred = obs.evidence === "inferred";
     for (const b of buckets) {
       const cur = perContext[b] ?? { confirmed: 0, contributors: [] };
       const contribs = new Set(cur.contributors ?? []);
-      if (obs.contributor) contribs.add(obs.contributor);
-      perContext[b] = { confirmed: cur.confirmed + 1, contributors: [...contribs] };
+      const inferredContribs = new Set(cur.inferredContributors ?? []);
+      if (obs.contributor) {
+        if (inferred) {
+          if (!contribs.has(obs.contributor)) inferredContribs.add(obs.contributor);
+        } else {
+          inferredContribs.delete(obs.contributor);
+        }
+        contribs.add(obs.contributor);
+      }
+      perContext[b] = {
+        ...cur,
+        confirmed: cur.confirmed + 1,
+        contributors: [...contribs],
+        ...inferredContribs.size > 0 ? { inferredContributors: [...inferredContribs] } : {}
+      };
+      if (inferredContribs.size === 0) delete perContext[b].inferredContributors;
     }
     const discriminator = obs.discriminator ?? existing?.attrs["discriminator"];
     const attrs = {
@@ -18864,8 +18879,10 @@ function triageOf(l2, q, mathOpts) {
         // Cloud-merged routes carry a distinct-uploader count; local routes count
         // their session contributors.
         independent: num2.independent ?? num2.contributors?.length ?? 0,
-        // Corpus-induced subset — discounted in the trust ramp (T3-weighting).
-        inferredIndependent: num2.inferredIndependent ?? 0
+        // Discounted-in-trust-ramp subset (T3-weighting): the cloud-authoritative
+        // corpus count when present, else the local inferred-only contributor count
+        // (ambient-paired diagnoses whose binding the daemon guessed).
+        inferredIndependent: num2.inferredIndependent ?? num2.inferredContributors?.length ?? 0
       };
     }
     const post = triagePosterior(counts, buckets, mathOpts);
@@ -22937,18 +22954,34 @@ function triageBullet(ref) {
     "    \xB7 the CAUSE is the mechanism you'd CHANGE in the code to make it stop \u2192 (cause: the mechanism)",
     "    Test: if the line says WHY it breaks, it's a (cause:), not a [!problem]. e.g. [!the runner",
     "    deadlocks after a task rejects] (cause: await fn() has no try/finally, so a rejection never",
-    `    decrements running). New cause as prose, or (cause:[${ref}]) to cite one shown.`
+    `    decrements running). New cause as prose, or (cause:[${ref}]) to cite one shown.`,
+    "    State the cause in the same breath as its symptom when you can. When a diagnosis",
+    "    UNFOLDS \u2014 symptom now, cause turns later, several problems in play \u2014 name the thread:",
+    "    [!#slug the symptom] once, then (cause:#slug \u2026) / (fix:#slug \u2026) bind to it exactly,",
+    "    however far apart. Same slug, your choice of word. Explaining a problem we SHOWED",
+    "    you? bind by its handle/id directly: (cause:#the-shown-handle \u2026) / (fix:#dprob_\u2026 \u2026)."
+  ].join("\n");
+}
+function attemptBullet() {
+  return [
+    "  \u2022 you're attempting an approach to a flagged problem, or an attempt didn't pan out:",
+    `    \xB7 ${TAG_EXAMPLE.tried()}`,
+    `    \xB7 ${TAG_EXAMPLE.failed()}`,
+    "    Failed attempts are knowledge \u2014 they rule out a path. Add #slug to bind to a named",
+    "    thread: (tried:#slug \u2026) / (failed:#slug \u2026)."
   ].join("\n");
 }
 function buildAgentInstruction(opts = {}) {
-  const signals = opts.signals ?? ["prior", "problem", "fix", "constraint", "triage"];
+  const signals = opts.signals ?? ["prior", "problem", "fix", "constraint", "triage", "attempt"];
   const ref = opts.referent ?? "its-handle";
-  const token = (s) => s === "problem" ? TAG_EXAMPLE.problem() : s === "constraint" ? TAG_EXAMPLE.constraint() : TAG_EXAMPLE[s](ref);
+  const token = (s) => s === "problem" ? TAG_EXAMPLE.problem() : s === "constraint" ? TAG_EXAMPLE.constraint() : s === "attempt" ? TAG_EXAMPLE.tried() : TAG_EXAMPLE[s](ref);
   const head2 = `We tag the priors we show you with a short handle like [${opts.handleExample ?? "chokidar-glob"}]. This is a capture protocol, not optional notes: what you DON'T tag is silently lost \u2014 the tag is the ONLY thing recorded. Whenever one of these is true, wrap it inline in your prose (no fences, no extra calls). Tag every one you state; we filter downstream, so don't self-censor or batch:`;
   const tail = "Mid-turn text (between tool calls) can be dropped by the harness \u2014 if a tag above appeared only mid-turn, RESTATE it in your final message of the turn; the final message always survives.";
   return [
     head2,
-    ...signals.map((s) => s === "triage" ? triageBullet(ref) : `  \u2022 ${GLOSS[s]} \u2192 ${token(s)}`),
+    ...signals.map(
+      (s) => s === "triage" ? triageBullet(ref) : s === "attempt" ? attemptBullet() : `  \u2022 ${GLOSS[s]} \u2192 ${token(s)}`
+    ),
     tail
   ].join("\n");
 }
@@ -22972,14 +23005,26 @@ var init_agent_signals = __esm({
       // (recallForFile) pastes this next to an open Problem that has no cause yet, so the
       // diagnostic moment is cued when the agent is looking at the problem. Kept here so
       // the grammar can't drift from parseInlineTags' `(cause: …)` acceptance.
-      triageMint: () => `(cause: why it happens)`
+      triageMint: () => `(cause: why it happens)`,
+      // THREAD forms — the witness-declared symptom↔cause/fix binding. A `#id` on the
+      // flag names the diagnosis thread; the same `#id` on a later verb binds to it
+      // explicitly (across sentences AND turns), replacing proximity guessing. Adjacent
+      // tags never need one — the id is for diagnoses that unfold over distance.
+      problemThread: () => `[!#slug one line on what's wrong]`,
+      causeThread: () => `(cause:#slug the mechanism)`,
+      fixThread: () => `(fix:#slug what you changed)`,
+      // ATTEMPT arc — what's being tried and what didn't work. A failed attempt is a
+      // witnessed NEGATIVE result: it saves the next agent the same dead end.
+      tried: () => `(tried: the approach you're attempting)`,
+      failed: () => `(failed: what didn't work and the dead end it rules out)`
     };
     GLOSS = {
       prior: "a prior we showed you helped \u2014 or this work sits in a primed language/package",
       problem: "you hit a real problem \u2014 incidental, or the one you're fixing",
       fix: "your edit fixes a problem \u2014 cite the one we showed you, or just say how you fixed one you found yourself: (fix: what you changed)",
       constraint: "you made a design decision because requirements conflict or something's constrained \u2014 tag the tension, ESPECIALLY when your fix makes it 'only look' contradictory (a clean solution still hides a real trap the next agent needs)",
-      triage: "you diagnosed a bug \u2014 SPLIT the symptom (what breaks \u2192 [!\u2026]) from the cause (the mechanism you'd change \u2192 (cause:\u2026)); if the line says WHY it breaks, it's a cause, not a problem"
+      triage: "you diagnosed a bug \u2014 SPLIT the symptom (what breaks \u2192 [!\u2026]) from the cause (the mechanism you'd change \u2192 (cause:\u2026)); if the line says WHY it breaks, it's a cause, not a problem",
+      attempt: "you're attempting an approach, or an attempt didn't pan out \u2014 (tried: \u2026) / (failed: \u2026); a failed attempt rules out a path for the next agent"
     };
   }
 });
@@ -39448,12 +39493,13 @@ import { readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "
 var NEG = /n['']t|\b(?:not|never|no|none|neither|nor|unrelated|irrelevant|would|might|could|if)\b/i;
 var CITE_GROUP_RE = /\(((?:[^()\n]|\([^()\n]*\)){1,200})\)/g;
 var HANDLE_RE = /\[([a-z0-9][\w-]{0,40})\]|((?:pat|sol|drc|dcause|dfix|dprob|prob|claim|err)_[0-9a-f]{6,})/gi;
-var FIX_PREFIX = /^\s*fix:\s*/i;
+var FIX_PREFIX = /^\s*fix:(?:#([a-z][\w-]{0,63}))?\s*/i;
 var CONSTRAINT_RE = /\(\s*constraint:\s*([^()\n]{8,}?)\s*\)/gi;
-var CAUSE_PREFIX = /^\s*cause:\s*/i;
+var CAUSE_PREFIX = /^\s*cause:(?:#([a-z][\w-]{0,63}))?\s*/i;
+var ATTEMPT_RE = /\(\s*(tried|failed):(?:#([a-z][\w-]{0,63}))?\s*((?:[^()\n]|\([^()\n]*\)){8,}?)\s*\)/gi;
 var CAUSE_TEXT_MIN = 8;
 var CAUSE_TEXT_MAX = 200;
-var FLAG_RE = /\[([!?])\s*([^\]\n]{8,}?)\s*(?:@\s*([^\s\]]+?)(?::(\d+))?\s*)?\]/g;
+var FLAG_RE = /\[([!?])(?:#([a-z][\w-]{0,63})\s+)?\s*([^\]\n]{8,}?)\s*(?:@\s*([^\s\]]+?)(?::(\d+))?\s*)?\]/g;
 var FLAG_MAX = 200;
 var CONSTRAINT_MIN = 8;
 function clauseBefore(sentence, idx) {
@@ -39472,19 +39518,25 @@ function fixRationaleBefore(sentence, idx) {
 function parseInlineTags(text) {
   const out2 = [];
   const deFenced = text.replace(/```[\s\S]*?```/g, " ");
+  let seqNo = -1;
   for (const raw2 of deFenced.split(/(?<=[.!?])\s+|\n+/)) {
+    seqNo++;
     if (raw2.length > 600) continue;
+    const seqStart = out2.length;
     const sentence = raw2.replace(
       /`[^`]*`/g,
-      (m) => /\[[!?]|\((?:fix|cause|constraint):|\(\[/.test(m) ? " " : m
+      (m) => /\[[!?]|\((?:fix|cause|constraint|tried|failed):|\(\[/.test(m) ? " " : m
     );
     const sfield = sentence.replace(/\s+/g, " ").trim().slice(0, 160);
     CITE_GROUP_RE.lastIndex = 0;
     let g;
     while ((g = CITE_GROUP_RE.exec(sentence)) !== null) {
       let content = g[1];
-      const isFix = FIX_PREFIX.test(content);
-      const isCause = !isFix && CAUSE_PREFIX.test(content);
+      const fixM = FIX_PREFIX.exec(content);
+      const causeM = fixM ? null : CAUSE_PREFIX.exec(content);
+      const isFix = fixM !== null;
+      const isCause = causeM !== null;
+      const verbThread = fixM?.[1] ?? causeM?.[1] ?? void 0;
       if (isFix) content = content.replace(FIX_PREFIX, "");
       else if (isCause) content = content.replace(CAUSE_PREFIX, "");
       if (isCause) {
@@ -39492,12 +39544,12 @@ function parseInlineTags(text) {
         const h2 = HANDLE_RE.exec(content);
         const handle2 = h2 ? h2[1] ?? h2[2] : void 0;
         if (handle2) {
-          out2.push({ kind: "triage", handle: handle2, sentence: sfield });
+          out2.push({ kind: "triage", handle: handle2, sentence: sfield, ...verbThread ? { threadId: verbThread } : {} });
         } else {
           const raw3 = content.replace(/\s+/g, " ").trim();
           if (raw3.length >= CAUSE_TEXT_MIN) {
             const causeText = raw3.length > CAUSE_TEXT_MAX ? `${raw3.slice(0, CAUSE_TEXT_MAX - 1).trimEnd()}\u2026` : raw3;
-            out2.push({ kind: "triage", causeText, sentence: sfield });
+            out2.push({ kind: "triage", causeText, sentence: sfield, ...verbThread ? { threadId: verbThread } : {} });
           }
         }
         continue;
@@ -39519,33 +39571,52 @@ function parseInlineTags(text) {
             kind: isFix ? "fix" : "prior",
             handle: handle2,
             sentence: sfield,
-            ...fixRationale ? { fixRationale } : {}
+            ...fixRationale ? { fixRationale } : {},
+            ...isFix && verbThread ? { threadId: verbThread } : {}
           });
         }
       }
       if (isFix && !emittedHandle) {
         const note = content.replace(/\s+/g, " ").trim();
-        if (note.length >= FIX_RATIONALE_MIN) out2.push({ kind: "fix", fixRationale: note, sentence: sfield });
+        if (note.length >= FIX_RATIONALE_MIN)
+          out2.push({ kind: "fix", fixRationale: note, sentence: sfield, ...verbThread ? { threadId: verbThread } : {} });
       }
     }
     FLAG_RE.lastIndex = 0;
     let f;
     while ((f = FLAG_RE.exec(sentence)) !== null) {
-      const raw3 = f[2].trim();
+      const flagThread = f[2];
+      const raw3 = f[3].trim();
       if (raw3.length >= 8) {
         const statement = raw3.length > FLAG_MAX ? `${raw3.slice(0, FLAG_MAX - 1).trimEnd()}\u2026` : raw3;
         const asFix = f[1] === "!" && /^(?:fixed|resolved)\s*[:,-]\s*/i.exec(statement);
         if (asFix) {
           const note = statement.slice(asFix[0].length).trim();
-          if (note.length >= FIX_RATIONALE_MIN) out2.push({ kind: "fix", fixRationale: note, sentence: sfield });
+          if (note.length >= FIX_RATIONALE_MIN)
+            out2.push({ kind: "fix", fixRationale: note, sentence: sfield, ...flagThread ? { threadId: flagThread } : {} });
           continue;
         }
-        const path2 = f[3]?.trim();
-        const location = path2 ? { path: path2, ...f[4] ? { line: Number(f[4]) } : {} } : void 0;
+        const path2 = f[4]?.trim();
+        const location = path2 ? { path: path2, ...f[5] ? { line: Number(f[5]) } : {} } : void 0;
         out2.push({
           kind: f[1] === "!" ? "problem" : "todo",
           statement,
           ...location ? { location } : {},
+          ...flagThread ? { threadId: flagThread } : {},
+          sentence: sfield
+        });
+      }
+    }
+    ATTEMPT_RE.lastIndex = 0;
+    let a;
+    while ((a = ATTEMPT_RE.exec(sentence)) !== null) {
+      const raw3 = a[3].replace(/\s+/g, " ").trim();
+      if (raw3.length >= CONSTRAINT_MIN) {
+        const statement = raw3.length > FLAG_MAX ? `${raw3.slice(0, FLAG_MAX - 1).trimEnd()}\u2026` : raw3;
+        out2.push({
+          kind: a[1].toLowerCase() === "tried" ? "attempt" : "failure",
+          statement,
+          ...a[2] ? { threadId: a[2] } : {},
           sentence: sfield
         });
       }
@@ -39559,6 +39630,7 @@ function parseInlineTags(text) {
         out2.push({ kind: "constraint", statement, sentence: sfield });
       }
     }
+    for (let i2 = seqStart; i2 < out2.length; i2++) out2[i2].seq = seqNo;
   }
   return out2;
 }
@@ -39669,13 +39741,36 @@ 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, problems: [], fixes: [], triages: [], unresolvedFixes: [] };
-  for (const tag of parseInlineTags(text)) {
+  const plan = { priorEdges: 0, problems: [], fixes: [], triages: [], attempts: [], unresolvedFixes: [] };
+  const tags = parseInlineTags(text);
+  const symptomSeqs = tags.filter((t) => (t.kind === "problem" || t.kind === "todo" || t.kind === "constraint") && t.statement).map((t) => ({ seq: t.seq ?? -1, statement: t.statement, threadId: t.threadId })).sort((a, b) => a.seq - b.seq);
+  const bindSymptom = (seq, threadId) => {
+    if (threadId) {
+      const hit = symptomSeqs.find((s) => s.threadId === threadId);
+      if (hit) return { statement: hit.statement, evidence: "witnessed" };
+      const cited = resolveHandle(store, threadId, opts.handleMap);
+      const citedNode = cited ? store.getNode(cited) : null;
+      if (citedNode) return { statement: citedNode.description, problemId: citedNode.id, evidence: "witnessed" };
+      return { evidence: "witnessed" };
+    }
+    if (seq == null) return { evidence: "inferred" };
+    let best;
+    for (const s of symptomSeqs) {
+      if (s.seq <= seq) best = s;
+      else break;
+    }
+    if (!best) return { evidence: "inferred" };
+    if (seq - best.seq <= 1) return { statement: best.statement, evidence: "witnessed" };
+    if (symptomSeqs.length === 1) return { statement: best.statement, evidence: "witnessed" };
+    return { statement: best.statement, evidence: "inferred" };
+  };
+  for (const tag of tags) {
     if (tag.kind === "problem" || tag.kind === "todo") {
       plan.problems.push({
         statement: tag.statement,
         kind: tag.kind,
-        ...tag.location ? { location: tag.location } : {}
+        ...tag.location ? { location: tag.location } : {},
+        ...tag.threadId ? { threadId: tag.threadId } : {}
       });
     } else if (tag.kind === "constraint") {
       plan.problems.push({ statement: tag.statement, kind: "problem" });
@@ -39685,16 +39780,47 @@ function harvestInlineTags(store, text, opts) {
         if (problemId) plan.fixes.push({ problemId, ...tag.fixRationale ? { fixNote: tag.fixRationale } : {} });
         else plan.unresolvedFixes.push({ handle: tag.handle, ...tag.fixRationale ? { fixNote: tag.fixRationale } : {} });
       } else if (tag.fixRationale) {
-        plan.fixes.push({ inScope: true, fixNote: tag.fixRationale });
+        const b = bindSymptom(tag.seq, tag.threadId);
+        if (b.problemId) {
+          plan.fixes.push({ problemId: b.problemId, fixNote: tag.fixRationale });
+        } else if (tag.threadId && !b.statement) {
+          plan.fixes.push({ inScope: true, fixNote: tag.fixRationale, threadId: tag.threadId });
+        } else if (b.statement && b.evidence === "witnessed") {
+          plan.fixes.push({ inScope: true, fixNote: tag.fixRationale, boundStatement: b.statement });
+        } else {
+          plan.fixes.push({ inScope: true, fixNote: tag.fixRationale, ambiguous: true });
+        }
       }
     } else if (tag.kind === "triage") {
+      const b = bindSymptom(tag.seq, tag.threadId);
+      const bound = {
+        ...b.statement ? { symptomStatement: b.statement } : {},
+        ...b.problemId ? { symptomProblemId: b.problemId } : {},
+        ...tag.threadId ? { threadId: tag.threadId } : {},
+        evidence: b.evidence
+      };
       if (tag.handle) {
         const causeId = resolveHandle(store, tag.handle, opts.handleMap);
         const node2 = causeId ? store.getNode(causeId) : null;
-        if (node2) plan.triages.push({ causeId: node2.id, causeDescription: node2.description });
+        if (node2) plan.triages.push({ causeId: node2.id, causeDescription: node2.description, ...bound });
       } else if (tag.causeText) {
         const causeId = `dcause_${digest({ statement: tag.causeText })}`.slice(0, 56);
-        plan.triages.push({ causeId, causeDescription: tag.causeText });
+        plan.triages.push({ causeId, causeDescription: tag.causeText, ...bound });
+      }
+    } else if (tag.kind === "attempt" || tag.kind === "failure") {
+      const b = bindSymptom(tag.seq, tag.threadId);
+      const outcome = tag.kind === "attempt" ? "tried" : "failed";
+      if (b.problemId) {
+        plan.attempts.push({ note: tag.statement, outcome, problemId: b.problemId });
+      } else if (tag.threadId && !b.statement) {
+        plan.attempts.push({ note: tag.statement, outcome, threadId: tag.threadId });
+      } else if (b.statement && b.evidence === "witnessed") {
+        plan.attempts.push({
+          note: tag.statement,
+          outcome,
+          ...tag.threadId ? { threadId: tag.threadId } : {},
+          boundStatement: b.statement
+        });
       }
     } else if (mintPriors && source) {
       const targetId = resolveHandle(store, tag.handle, opts.handleMap);
@@ -40951,7 +41077,7 @@ function maybeFlushDigests() {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.0-dev.20" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.0-dev.22" : "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;
@@ -41375,6 +41501,7 @@ function createWorkspaceEngine(opts) {
   const turnCursorPath = join19(paths.configDir, "turn-cursors.json");
   const lastTurnUuid = loadTurnCursors(turnCursorPath);
   const sessionLastProblem = /* @__PURE__ */ new Map();
+  const sessionThreads = /* @__PURE__ */ new Map();
   const harvestTexts = async (sessionId, items) => {
     if (items.length === 0) return;
     let minted = 0;
@@ -41488,6 +41615,8 @@ function createWorkspaceEngine(opts) {
         priorEdges += plan.priorEdges;
         const wf = workingFiles.get(sessionId);
         let inScopeProblemId;
+        const threads = sessionThreads.get(sessionId) ?? /* @__PURE__ */ new Map();
+        sessionThreads.set(sessionId, threads);
         for (const p of plan.problems) {
           const anchorPath = p.location?.path ?? turnFile ?? wf;
           if (anchorPath) {
@@ -41497,6 +41626,7 @@ function createWorkspaceEngine(opts) {
                 minted++;
                 sessionLastProblem.set(sessionId, dupId);
                 inScopeProblemId = dupId;
+                if (p.threadId) threads.set(p.threadId, dupId);
                 continue;
               }
             } catch {
@@ -41511,6 +41641,7 @@ function createWorkspaceEngine(opts) {
             minted++;
             sessionLastProblem.set(sessionId, designProblemId(p.statement));
             inScopeProblemId = designProblemId(p.statement);
+            if (p.threadId) threads.set(p.threadId, designProblemId(p.statement));
             if (anchorPath) {
               try {
                 if (anchorProblemToWorkingFile(store, r.problemId, anchorPath, profile.id, t)) {
@@ -41527,8 +41658,16 @@ function createWorkspaceEngine(opts) {
           );
         }
         for (const fx of plan.fixes) {
-          const pid = fx.inScope ? inScopeProblemId : fx.problemId;
-          if (pid && resolveDesignProblemById(store, pid, fx.fixNote, t)) {
+          const pid = fx.problemId ?? (fx.threadId ? threads.get(fx.threadId) : void 0) ?? (fx.boundStatement ? designProblemId(fx.boundStatement) : void 0);
+          if (!pid) {
+            if (fx.inScope) {
+              console.warn(
+                `[errata] fix tag not bound: ${fx.threadId ? `thread "#${fx.threadId}" unknown in this session` : "several candidate problems, none adjacent"} \u2014 NOT resolved (bind with (fix:#thread-id \u2026) or state it beside its [!problem])` + (fx.fixNote ? `; note: "${fx.fixNote.slice(0, 80)}"` : "")
+              );
+            }
+            continue;
+          }
+          if (resolveDesignProblemById(store, pid, fx.fixNote, t)) {
             resolved++;
             const fxAnchor = turnFile ?? wf;
             if (fxAnchor) {
@@ -41542,28 +41681,62 @@ function createWorkspaceEngine(opts) {
           }
         }
         if (opts.sharedStore && plan.triages.length > 0) {
-          const symptomId = sessionLastProblem.get(sessionId);
-          const symptom = symptomId ? store.getNode(symptomId) : void 0;
-          if (symptom) {
-            for (const tr of plan.triages) {
-              if (tr.causeId === symptomId) continue;
-              try {
-                recordTriageObservation(
-                  opts.sharedStore,
-                  {
-                    presentingStatement: symptom.description,
-                    causeId: tr.causeId,
-                    ...tr.causeDescription ? { causeDescription: tr.causeDescription } : {},
-                    context: { stack: profile.stack, domain: profile.domains[0] },
-                    contributor: sessionId
-                  },
-                  t
-                );
-                triaged++;
-              } catch (err2) {
-                console.warn("[errata] inline triage route failed:", err2);
+          const fallbackId = sessionLastProblem.get(sessionId);
+          const fallbackStatement = fallbackId ? store.getNode(fallbackId)?.description : void 0;
+          for (const tr of plan.triages) {
+            let presentingStatement = tr.symptomStatement;
+            let evidence = tr.evidence;
+            if (!presentingStatement && tr.threadId) {
+              const threadPid = threads.get(tr.threadId);
+              const threadNode = threadPid ? store.getNode(threadPid) : void 0;
+              if (threadNode) {
+                presentingStatement = threadNode.description;
+              } else {
+                console.warn(`[errata] cause tag: thread "#${tr.threadId}" unknown in this session \u2014 falling back at inferred weight`);
+                evidence = "inferred";
               }
             }
+            if (!presentingStatement) {
+              presentingStatement = fallbackStatement;
+              evidence = "inferred";
+            }
+            if (!presentingStatement) continue;
+            const presentingId = tr.symptomProblemId ?? designProblemId(presentingStatement);
+            if (tr.causeId === presentingId) continue;
+            try {
+              recordTriageObservation(
+                opts.sharedStore,
+                {
+                  presentingStatement,
+                  presentingId,
+                  causeId: tr.causeId,
+                  ...tr.causeDescription ? { causeDescription: tr.causeDescription } : {},
+                  context: { stack: profile.stack, domain: profile.domains[0] },
+                  contributor: sessionId,
+                  evidence
+                },
+                t
+              );
+              triaged++;
+            } catch (err2) {
+              console.warn("[errata] inline triage route failed:", err2);
+            }
+          }
+        }
+        for (const at of plan.attempts) {
+          const pid = at.problemId ?? (at.threadId ? threads.get(at.threadId) : void 0) ?? (at.boundStatement ? designProblemId(at.boundStatement) : void 0);
+          const node2 = pid ? store.getNode(pid) : void 0;
+          if (!pid || !node2) continue;
+          try {
+            const journal = Array.isArray(node2.attrs["attempts"]) ? [...node2.attrs["attempts"]] : [];
+            journal.push({ note: at.note, outcome: at.outcome, session: sessionId, ts: t });
+            store.updateNode(pid, {
+              attrs: { ...node2.attrs, attempts: journal.slice(-20) },
+              // cap — newest wins
+              lastUpdatedAt: t
+            });
+          } catch (err2) {
+            console.warn("[errata] attempt journal failed:", err2);
           }
         }
       } catch (err2) {

package/package.json

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