@inerrata-corporation/errata 2.0.2-dev.288 → 2.0.2-dev.297

package/consolidate-worker.mjs

@@ -15214,7 +15214,12 @@ var init_edge_rules = __esm({
       // ── Taxonomy (Track 4 Stream C: MITRE CWE `ChildOf` → `Weakness —IS_A→ Weakness`) ──
       IS_A: { from: ["Weakness"], to: ["Weakness"] },
       // ── Conceptual (v1 taxonomy.ts: instance → motif/pattern reference) ──
-      INSTANCE_OF: { to: ["Pattern", "Weakness", "Technique"] },
+      // `AntiPattern` joined the target set 2026-08-02: it is one of the three motif
+      // kinds (generalizer motifs.ts `layerOf`: pattern | technique | antipattern) and
+      // the SUPPRESSED-close path mints `Problem ─INSTANCE_OF→ AntiPattern` as the
+      // negative-knowledge binding ("silenced, not solved") — the original three-label
+      // rule predates AntiPattern joining the motif layer and silently ate that edge.
+      INSTANCE_OF: { to: ["Pattern", "AntiPattern", "Weakness", "Technique"] },
       IMPLEMENTS: { from: ["Solution", "Language", "Component"], to: ["Pattern", "Technique"] },
       MATCHES: { to: ["Pattern"] },
       // ── Artifact evidence (v1 taxonomy.ts artifact rows) ──
@@ -15772,7 +15777,15 @@ var LOCAL_RULE_OVERRIDES = {
     to: [...CODE_NODE_LABELS, "Symbol"]
   },
   REVEALED_BY: null,
-  PRODUCED: null
+  PRODUCED: null,
+  // FIXED_BY locally ALSO carries the fix-provenance sense: `resolveProblem`
+  // attributes a closed Problem to the fixing `Episode` (PLAN_PLASTICITY §2.1)
+  // alongside the cloud's Problem→Solution knowledge claim. Same shape as
+  // PRODUCED/REVEALED_BY above — an Episode is code-layer and never drains, so
+  // the cloud door's `to: [Solution]` rule is untouched. The `from` constraint
+  // stays: the reversed (Solution)-FIXED_BY->(...) splash bug is the reason
+  // this rule exists at all.
+  FIXED_BY: { from: EDGE_RULES["FIXED_BY"]?.from, to: ["Solution", "Episode"] }
 };
 function localEdgeViolation(fromLabel, type, toLabel) {
   if (type in LOCAL_RULE_OVERRIDES) {

package/errata.mjs

@@ -15389,7 +15389,12 @@ var init_edge_rules = __esm({
       // ── Taxonomy (Track 4 Stream C: MITRE CWE `ChildOf` → `Weakness —IS_A→ Weakness`) ──
       IS_A: { from: ["Weakness"], to: ["Weakness"] },
       // ── Conceptual (v1 taxonomy.ts: instance → motif/pattern reference) ──
-      INSTANCE_OF: { to: ["Pattern", "Weakness", "Technique"] },
+      // `AntiPattern` joined the target set 2026-08-02: it is one of the three motif
+      // kinds (generalizer motifs.ts `layerOf`: pattern | technique | antipattern) and
+      // the SUPPRESSED-close path mints `Problem ─INSTANCE_OF→ AntiPattern` as the
+      // negative-knowledge binding ("silenced, not solved") — the original three-label
+      // rule predates AntiPattern joining the motif layer and silently ate that edge.
+      INSTANCE_OF: { to: ["Pattern", "AntiPattern", "Weakness", "Technique"] },
       IMPLEMENTS: { from: ["Solution", "Language", "Component"], to: ["Pattern", "Technique"] },
       MATCHES: { to: ["Pattern"] },
       // ── Artifact evidence (v1 taxonomy.ts artifact rows) ──
@@ -16497,7 +16502,15 @@ var init_store = __esm({
         to: [...CODE_NODE_LABELS, "Symbol"]
       },
       REVEALED_BY: null,
-      PRODUCED: null
+      PRODUCED: null,
+      // FIXED_BY locally ALSO carries the fix-provenance sense: `resolveProblem`
+      // attributes a closed Problem to the fixing `Episode` (PLAN_PLASTICITY §2.1)
+      // alongside the cloud's Problem→Solution knowledge claim. Same shape as
+      // PRODUCED/REVEALED_BY above — an Episode is code-layer and never drains, so
+      // the cloud door's `to: [Solution]` rule is untouched. The `from` constraint
+      // stays: the reversed (Solution)-FIXED_BY->(...) splash bug is the reason
+      // this rule exists at all.
+      FIXED_BY: { from: EDGE_RULES["FIXED_BY"]?.from, to: ["Solution", "Episode"] }
     };
     SCHEMA_VERSION = 6;
     SCHEMA_SQL = `
@@ -21283,13 +21296,10 @@ function renderSnapshot(s) {
   const lines = [];
   lines.push("## Errata context");
   lines.push("");
-  lines.push("### \u270D\uFE0F CAPTURE PROTOCOL \u2014 do this as you work, it IS the work");
+  lines.push("### \u270D\uFE0F CAPTURE PROTOCOL \u2014 tags are the record");
   lines.push(
-    "errata auto-derives problems/fixes from your edits/commands. But two signals exist ONLY if you write them inline \u2014 and the tag is the ONLY thing recorded: a problem or fix you state in plain prose, a markdown list, or your own numbering is SILENTLY LOST. So the moment you state one, wrap it (no tool call, no fence):"
+    "errata records ONLY inline tags: `[!one line]` for every problem you state, `(fix:[id])` when your edit fixed a shown problem. Untagged prose is silently lost \u2014 tag as you write (no fences), we filter downstream."
   );
-  lines.push("- `[!one line]` \u2014 EVERY problem you notice or report (a bug you read past, an audit/review finding, anything you call out)");
-  lines.push("- `(fix:[id])` \u2014 your edit fixed a problem errata showed you (ids appear in the priors below / in file priors)");
-  lines.push("Tag every one you state \u2014 we filter downstream, so don't self-censor or batch. This is the witness only you can give; untagged, it's lost.");
   lines.push("");
   lines.push(SEARCH_IMPERATIVE_HEADER);
   lines.push(SEARCH_IMPERATIVE_BODY);
@@ -25524,61 +25534,36 @@ function buildFileRecallInstruction(referent = "\u2026") {
 }
 function triageBullet(ref) {
   return [
-    "  \u2022 you diagnosed a bug \u2014 write the CAUSAL CHAIN in one flag with `<-` (caused-by).",
-    "    Don't split it into a second tag you'll skip under load; fold it the way you'd say it:",
-    "    \xB7 [!the symptom <- the mechanism] \u2014 leftmost is what breaks observably (what a test",
-    "      or user reports); the step right is what caused it. e.g. [!the runner deadlocks after",
-    "      a task rejects <- await fn() has no try/finally, so a rejection never decrements running].",
-    "    \xB7 chain it as deep as you actually diagnosed: [!symptom <- cause <- root cause] \u2014 every",
-    "      ` <- ` is a link we record, and the RIGHTMOST is the reusable root cause (the node other",
-    "      agents find). Stop at the deepest mechanism you're sure of; don't guess a link.",
-    "    When symptom and cause turn up FAR APART \u2014 the cause lands turns later, several problems",
-    "    in play \u2014 name the thread instead: [!#slug the symptom] once, then (cause:#slug the",
-    "    mechanism) binds to it however far away (same slug, your choice of word). Explaining a",
-    `    problem we SHOWED you? bind by its handle/id: (cause:[${ref}] \u2026) / (cause:#dprob_\u2026 \u2026).`
+    "  \u2022 you diagnosed a cause \u2014 fold the chain into the flag with <- (caused-by), deepest",
+    "    sure mechanism rightmost: [!symptom <- cause <- root cause]. Symptom and cause far",
+    "    apart? open a thread [!#slug symptom] \u2026 later bind (cause:#slug mechanism);",
+    `    explaining a problem we SHOWED you \u2192 (cause:[${ref}] \u2026)`
   ].join("\n");
 }
 function linkBullet(ref) {
   return [
-    // Lead-in states the trigger without the old "resembles prior knowledge"
-    // conditional (which gated the whole bullet on recognising a prior). Kept to ONE
-    // line on purpose: Cycle 13 measured this instruction at 55% of the 9,000-char
-    // passive-context budget, and every char here is paid for by evicting a prior the
-    // agent could have cited — so unproven framing is a net loss, however good it reads.
-    "  \u2022 you flagged a problem \u2014 LINK it, ESPECIALLY when the finding feels novel to here:",
-    `    \xB7 (instance:[${ref}],[another-prior],\u2026) \u2014 the priors this problem is an instance of.`,
-    "      Aim for ~3 DIFFERENT relevant priors; one link is weak, three triangulate it.",
-    `    \xB7 ${TAG_EXAMPLE.pattern()} \u2014 name the general shape it instantiates (e.g. (pattern: unbounded`,
-    "      queue growth under backpressure)) \u2014 this works with NO code anchor, and two agents naming",
-    "      the same pattern converge on one node. Cite a shown Pattern by handle: (pattern:[handle]).",
-    `    \xB7 ${TAG_EXAMPLE.package()} \u2014 the PUBLIC PACKAGE the problem is about, even when this`,
-    "      workspace doesn't depend on it (e.g. (package: chokidar), (package: pypi/requests)) \u2014 a",
-    "      public-registry anchor lets the knowledge cross to the collective; internal names stay private.",
-    `    \xB7 ${TAG_EXAMPLE.component()} \u2014 the framework/product-level UNIT it concerns when it's not a`,
-    "      package or a language (e.g. (component: React Router), (component: V8 Isolate)).",
-    `    \xB7 (aids:[${ref}],\u2026) \u2014 your FIX could also help these other, even unrelated, problems.`,
-    "      A hypothesis, not a claim \u2014 it's recorded as may-resolve and checked by whoever tries it.",
-    `    \xB7 when your fix relates to a PRIOR solution you were primed with (a problem's`,
-    `      "already solved by" line): (builds-on:[${ref}]) if you layer on it \xB7 (supersedes:[${ref}])`,
-    "      if you replace it \xB7 (alternative:[h]) if it's a different approach \u2014 pick one. This is the",
-    "      only way N solutions on one problem stop being a flat bag."
+    "  \u2022 link what you flag:",
+    `    \xB7 (instance:[${ref}],[another],[a-third]) \u2014 priors it instantiates; ~3 DIFFERENT ones triangulate`,
+    "    \xB7 (pattern:[handle]) \u2014 cite a shown Pattern",
+    `    \xB7 ${TAG_EXAMPLE.package()} \u2014 the PUBLIC package it's about, dependency or not`,
+    `    \xB7 ${TAG_EXAMPLE.component()} \u2014 the framework/product unit`,
+    `    \xB7 (aids:[${ref}],\u2026) \u2014 other problems your fix might also resolve (hypothesis)`,
+    `    \xB7 your fix vs a shown solution: (builds-on:[${ref}]) \xB7 (supersedes:[${ref}]) \xB7 (alternative:[h]) \u2014 pick one`
   ].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)."
+    `  \u2022 attempting an approach / an attempt failed \u2192 ${TAG_EXAMPLE.tried()} \xB7`,
+    `    ${TAG_EXAMPLE.failed()} \u2014 a failed attempt is knowledge;`,
+    "    bind to a thread with (tried:#slug \u2026) / (failed:#slug \u2026)"
   ].join("\n");
 }
 function buildAgentInstruction(opts = {}) {
   const signals = opts.signals ?? ["prior", "problem", "domain", "fix", "constraint", "triage", "attempt", "link"];
   const ref = opts.referent ?? "its-handle";
   const token = (s) => s === "problem" ? TAG_EXAMPLE.problem() : s === "constraint" ? TAG_EXAMPLE.constraint() : s === "attempt" ? TAG_EXAMPLE.tried() : s === "domain" ? TAG_EXAMPLE.domain() : s === "link" ? TAG_EXAMPLE.pattern() : 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.";
+  const head2 = `We tag the priors we show you with a short handle like [${opts.handleExample ?? "chokidar-glob"}]. Tags are the ONLY signal recorded \u2014 anything you state but don't tag is silently lost. Weave each tag inline in your prose as you state it (no fences or backticks, no extra calls); tag everything, we filter downstream:`;
+  const tail = "Mid-turn text (between tool calls) can be dropped by the harness \u2014 RESTATE every tag in your turn-final message; the final message is what reliably survives.";
   return [
     head2,
     ...signals.map(
@@ -25636,12 +25621,12 @@ var init_agent_signals = __esm({
       aids: (ref) => `(aids:[${ref}])`
     };
     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. About specific code? NAME the file in the tag: [!what's wrong @ src/file.ts:42] \u2014 we anchor to what you name, or to a file you edited this turn, never to one you merely read; a design/topic problem is fine with no @",
-      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",
-      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",
+      prior: "a shown prior helped, or you work in a primed language/package",
+      problem: "a problem you notice or report \u2014 any bug, finding, or thing wrong; about specific code? name the file: [!what's wrong @ src/file.ts:42]",
+      fix: "your edit fixed a PROBLEM we showed you; for one you flagged yourself: (fix: what you changed) \u2014 a fix resolves a stated problem, completing routine work is not a fix",
+      constraint: "a design decision forced by conflicting requirements or constraints \u2014 tag the tension, especially when your fix makes it 'only look' resolved",
+      triage: "you diagnosed a cause \u2014 fold the chain into the flag with <- (caused-by), deepest sure mechanism rightmost",
+      attempt: "attempting an approach / an attempt failed \u2014 a failed attempt is knowledge, it rules out a path",
       // DOMAIN — promoted to a FIRST-CLASS signal (was nested inside linkBullet, whose
       // lead-in gates on "a problem you flagged resembles prior knowledge"). Naming the
       // area a problem is about is unconditional and has nothing to do with recognizing
@@ -25657,7 +25642,10 @@ var init_agent_signals = __esm({
       // contribution, so stating the general area reads as vague restatement — exactly
       // when it matters most, because precise wording is what makes a problem
       // unfindable to anyone who doesn't already share it.
-      domain: "you flagged a problem that isn't about one specific file \u2014 name the AREA it's about. The sharper your wording, the LESS anyone else will search for it; an abstract problem with no area is an invisible island. Title Case",
+      // Sim note (2026-08-02 shrink): domain emission held 4/4 with just the trigger
+      // clause; the pattern convergence hook now rides here too (it fell 0/4 when it
+      // only appeared in the link bullet's tail).
+      domain: "a problem with no single file \u2014 name the area it's about (Title Case). Also name the general shape it instantiates: (pattern: the shape) \u2014 needs no code anchor, and two agents naming the same shape converge on one node",
       link: "the problem you flagged is an instance of priors/abstractions you can name \u2014 (instance:[h1],[h2],\u2026) / (pattern: \u2026) / (aids:[h]); rendered whole via linkBullet"
     };
   }
@@ -26837,7 +26825,7 @@ function bindCanonicalNeighbors(store, opts) {
   let bound = 0;
   for (const p of problems) {
     const existing = new Set(
-      store.outEdges(p.id, ["MATCHES", "INSTANCE_OF"]).map((e) => e.to)
+      store.outEdges(p.id, ["MATCHES", "INSTANCE_OF", "RELATES_TO"]).map((e) => e.to)
     );
     if (existing.size >= k) continue;
     const ranked = candidates.filter(
@@ -52906,7 +52894,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.288" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.297" : "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;

package/package.json

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

package/pass-worker.mjs

@@ -15069,7 +15069,12 @@ var init_edge_rules = __esm({
       // ── Taxonomy (Track 4 Stream C: MITRE CWE `ChildOf` → `Weakness —IS_A→ Weakness`) ──
       IS_A: { from: ["Weakness"], to: ["Weakness"] },
       // ── Conceptual (v1 taxonomy.ts: instance → motif/pattern reference) ──
-      INSTANCE_OF: { to: ["Pattern", "Weakness", "Technique"] },
+      // `AntiPattern` joined the target set 2026-08-02: it is one of the three motif
+      // kinds (generalizer motifs.ts `layerOf`: pattern | technique | antipattern) and
+      // the SUPPRESSED-close path mints `Problem ─INSTANCE_OF→ AntiPattern` as the
+      // negative-knowledge binding ("silenced, not solved") — the original three-label
+      // rule predates AntiPattern joining the motif layer and silently ate that edge.
+      INSTANCE_OF: { to: ["Pattern", "AntiPattern", "Weakness", "Technique"] },
       IMPLEMENTS: { from: ["Solution", "Language", "Component"], to: ["Pattern", "Technique"] },
       MATCHES: { to: ["Pattern"] },
       // ── Artifact evidence (v1 taxonomy.ts artifact rows) ──
@@ -24079,7 +24084,15 @@ var LOCAL_RULE_OVERRIDES = {
     to: [...CODE_NODE_LABELS, "Symbol"]
   },
   REVEALED_BY: null,
-  PRODUCED: null
+  PRODUCED: null,
+  // FIXED_BY locally ALSO carries the fix-provenance sense: `resolveProblem`
+  // attributes a closed Problem to the fixing `Episode` (PLAN_PLASTICITY §2.1)
+  // alongside the cloud's Problem→Solution knowledge claim. Same shape as
+  // PRODUCED/REVEALED_BY above — an Episode is code-layer and never drains, so
+  // the cloud door's `to: [Solution]` rule is untouched. The `from` constraint
+  // stays: the reversed (Solution)-FIXED_BY->(...) splash bug is the reason
+  // this rule exists at all.
+  FIXED_BY: { from: EDGE_RULES["FIXED_BY"]?.from, to: ["Solution", "Episode"] }
 };
 function localEdgeViolation(fromLabel, type, toLabel) {
   if (type in LOCAL_RULE_OVERRIDES) {