@inerrata-corporation/errata 2.0.22-dev.4135 → 2.0.22-dev.4164

package/errata.mjs

@@ -94,7 +94,7 @@ function toCloudAttrs(attrs) {
   }
   return rest2;
 }
-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 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, PROJECT_SYNC_EDGE_TYPES, 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";
@@ -321,6 +321,7 @@ var init_castalia = __esm({
     ABSTRACTION_EDGES = ["GENERALIZES", "DERIVED_FROM"];
     DECOMPOSITION_EDGES = ["SPLIT_INTO"];
     TRANSFER_EDGES = ["MAY_RESOLVE"];
+    PROJECT_SYNC_EDGE_TYPES = ["SOLVED_BY", "CAUSED_BY", "FIXED_BY", "MAY_RESOLVE"];
     SOLUTION_STRUCTURE_EDGES = ["BUILDS_ON", "SUPERSEDES", "ALTERNATIVE_TO"];
     SUSPICION_EDGES = ["SUSPECTED_LINK", "REGRESSION_OF"];
     TAXONOMY_EDGES = ["IS_A"];
@@ -17625,6 +17626,7 @@ __export(src_exports, {
   PROBLEM_RESOLUTION: () => PROBLEM_RESOLUTION,
   PROJECT_ONLY_EDGE_TYPES: () => PROJECT_ONLY_EDGE_TYPES,
   PROJECT_ONLY_NODE_LABELS: () => PROJECT_ONLY_NODE_LABELS,
+  PROJECT_SYNC_EDGE_TYPES: () => PROJECT_SYNC_EDGE_TYPES,
   QUARANTINE_EXTRACTION_SOURCE_PREFIX: () => QUARANTINE_EXTRACTION_SOURCE_PREFIX,
   REDACTED_CREDENTIAL: () => REDACTED_CREDENTIAL,
   REDACTED_EMAIL: () => REDACTED_EMAIL,
@@ -18205,6 +18207,603 @@ var init_sqlite_adapter = __esm({
   }
 });
 
+// ../../packages/local-shared/src/tag-grammar.ts
+function tagGrammarCopy() {
+  const copy = [];
+  for (const ref of ["its-handle", "its-id", "h", "id"]) {
+    for (const build of Object.values(TAG_EXAMPLES)) copy.push(build(ref));
+  }
+  for (const v of TAG_VERBS) {
+    copy.push(v.hint);
+    if (v.taughtBy) copy.push(v.taughtBy);
+    for (const q of v.qualifiers ?? []) copy.push(q.note);
+    for (const l of v.lowering) {
+      if (l.note) copy.push(l.note);
+      if (l.knownViolation) copy.push(l.knownViolation.finding);
+    }
+  }
+  for (const f of TAG_FENCES) copy.push(f.hint);
+  return copy;
+}
+function normalizeTemplateBody(body2) {
+  return body2.replace(/…|\.{3}/g, " ").replace(/\s+/g, " ").trim().replace(/^[\s,;:—–-]+|[\s,;:.—–-]+$/g, "").toLowerCase();
+}
+function deriveTagTemplates(copy) {
+  const bodies = /* @__PURE__ */ new Set();
+  const handles = new Set([...TAG_PLACEHOLDER_HANDLES].map((h) => h.toLowerCase()));
+  for (const text of copy) {
+    for (const m of text.matchAll(BRACKET_TOKEN)) {
+      const token = m[1].trim().toLowerCase();
+      if (!/^[!?]/.test(token) && !REAL_HANDLE_SHAPE.test(token)) handles.add(token);
+    }
+  }
+  for (const text of copy) {
+    for (const m of text.matchAll(TEMPLATE_VERB_GROUP)) {
+      const body2 = normalizeTemplateBody(m[2]);
+      bodies.add(body2);
+      const unthreaded = normalizeTemplateBody(body2.replace(/^#[a-z][\w-]*/i, ""));
+      bodies.add(unthreaded);
+      const rest2 = normalizeTemplateBody(unthreaded.replace(BRACKET_TOKEN, (t, h) => handles.has(h.trim().toLowerCase()) ? " " : t).replace(/,/g, " "));
+      bodies.add(rest2);
+    }
+  }
+  bodies.delete("");
+  return { bodies, handles };
+}
+function isTemplateSegment(verb, text, templates) {
+  const t = normalizeTemplateBody(text);
+  if (t === "" || templates.bodies.has(t)) return true;
+  const unthreaded = normalizeTemplateBody(t.replace(/^#[a-z][\w-]*/i, ""));
+  if (unthreaded === "" || templates.bodies.has(unthreaded)) return true;
+  let real = false;
+  let standIn = false;
+  const rest2 = unthreaded.replace(BRACKET_TOKEN, (token, inner) => {
+    const h = inner.trim().toLowerCase();
+    if (/^[!?]/.test(h)) return token;
+    if (templates.handles.has(h) || /…|\.{3}/.test(h) || !REAL_HANDLE_SHAPE.test(h)) standIn = true;
+    else real = true;
+    return " ";
+  });
+  if (standIn || real) return true;
+  const words = normalizeTemplateBody(rest2.replace(ANY_VERB_WORD, " ").replace(/,/g, " "));
+  if (words === "" || templates.bodies.has(words)) return true;
+  const spec = verb ? TAG_VERB_BY_NAME.get(verb) : void 0;
+  if (!spec || spec.handleRequired) return true;
+  return words.length < (spec.minText ?? 2);
+}
+function isTemplateTagBody(verb, body2, templates = TAG_TEMPLATES) {
+  const whole = normalizeTemplateBody(body2);
+  if (whole === "" || templates.bodies.has(whole)) return true;
+  const segments = body2.split(JOINED_VERB);
+  return segments.every((seg, i2) => {
+    const lead2 = i2 === 0 ? null : LEADING_VERB.exec(seg);
+    return isTemplateSegment(lead2 ? lead2[1].toLowerCase() : verb, lead2 ? seg.slice(lead2[0].length) : seg, templates);
+  });
+}
+function quotesOnlyTemplateTags(span, templates = TAG_TEMPLATES) {
+  let found = false;
+  for (const m of span.matchAll(QUOTED_TAG_OPENER)) {
+    found = true;
+    if (m.index > 0 && /[\w$.\])]/.test(span[m.index - 1])) continue;
+    const bodyStart = m.index + m[0].length;
+    let depth = 1;
+    let close = -1;
+    for (let i2 = bodyStart; i2 < span.length; i2++) {
+      if (span[i2] === "(") depth++;
+      else if (span[i2] === ")" && --depth === 0) {
+        close = i2;
+        break;
+      }
+    }
+    if (close < 0) continue;
+    if (!isTemplateTagBody(m[1]?.toLowerCase() ?? null, span.slice(bodyStart, close), templates)) return false;
+  }
+  return found;
+}
+var TAG_CANONICAL_ID_PREFIXES, TAG_HANDLE_SOURCE, TAG_THREAD_SOURCE, TAG_PLACEHOLDER_HANDLES, TAG_EXAMPLES, P, S, RC, CITE_LOWERING, INSTANCE_LOWERING, TRIAGE_TO_RC, TAG_VERBS, TAG_FENCES, TAG_VERB_BY_NAME, TAG_PAREN_VERBS, TAG_GRAMMAR_OPENERS, TAG_QUOTED_PAREN_SOURCE, TAG_QUOTED_RE, TAG_QUOTED_PAREN_RE, TEMPLATE_VERB_GROUP, BRACKET_TOKEN, REAL_HANDLE_SHAPE, TAG_TEMPLATES, VERB_WORDS_SOURCE, JOINED_VERB, LEADING_VERB, ANY_VERB_WORD, QUOTED_TAG_OPENER, TAG_VERDICT_TOKENS;
+var init_tag_grammar = __esm({
+  "../../packages/local-shared/src/tag-grammar.ts"() {
+    "use strict";
+    TAG_CANONICAL_ID_PREFIXES = ["pat", "sol", "drc", "dcause", "dfix", "dprob", "dvuln", "prob", "claim", "err"];
+    TAG_HANDLE_SOURCE = String.raw`\[([a-z0-9][\w-]{0,80})\]|((?:${TAG_CANONICAL_ID_PREFIXES.join("|")})_[0-9a-f]{6,})`;
+    TAG_THREAD_SOURCE = String.raw`#([a-z][\w-]{0,63})`;
+    TAG_PLACEHOLDER_HANDLES = /* @__PURE__ */ new Set([
+      "handle",
+      "its-handle",
+      "another",
+      "a-third",
+      "h",
+      "h1",
+      "h2",
+      "id",
+      "its-id",
+      "a",
+      "b",
+      "\u2026",
+      "..."
+    ]);
+    TAG_EXAMPLES = {
+      prior: (ref) => `([${ref}])`,
+      problem: () => `[!one line on what's wrong]`,
+      vulnerability: () => `[!vuln: who can do what; observed basis @ path:line]`,
+      suspectedVulnerability: () => `[?vuln: consequence; missing check]`,
+      vulnerabilityThread: () => `[!#v vuln: finding here]`,
+      fix: (ref) => `(fix:[${ref}])`,
+      // CONSTRAINT — the native capture path for a DIFFUSE problem (a constraint/tension/
+      // conflict that shaped a decision). Free text, attaches to the decision sentence the
+      // agent is already writing. Full rationale in the constraint note below + prior-tags.ts.
+      constraint: () => `(constraint: the limitation that forced it)`,
+      // TRIAGE — routes the problem/symptom in scope to its cause. `(cause:[handle])`
+      // links to a cited RootCause/Solution node; `(cause: free text)` mints a RootCause
+      // from the text. Harvested in prior-tags.ts → engine.ts (see the triage note below).
+      triage: (ref) => `(cause:[${ref}])`,
+      // Unlike a bare cause citation, this handle names the Problem being explained.
+      triageExplain: (ref) => `(cause:[${ref}] the mechanism)`,
+      // The MINT form — free-text cause that mints a RootCause. Prime-time surfacing
+      // (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)`,
+      // 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: (thread = "slug") => `(fix:#${thread} 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)`,
+      // `(failed:[h] …)` on a shown SOLUTION — the refute-by-failure form the context render teaches.
+      failedCite: (ref) => `(failed:[${ref}] what came back)`,
+      // LINK verbs (AC epic) — bind the problem in scope to CANONICAL priors and
+      // abstractions. Multi-target by design: single links are weak; ~3 links to 3
+      // DIFFERENT relevant priors is the target shape (see linkBullet).
+      instance: (ref) => `(instance:[${ref}],[another],[a-third])`,
+      pattern: () => `(pattern: name the general shape)`,
+      // DOMAIN — the abstract area a problem is about; the concept layer an
+      // anchor-less problem clusters on. Mints/resolves a Domain by name.
+      domain: () => `(domain: The Area)`,
+      // PACKAGE/COMPONENT — agent-named public anchors (OM-agent-anchors): the
+      // package a problem is ABOUT (even when not a dependency) and the
+      // framework/product-level unit it concerns. Public spine anchors → the
+      // knowledge can cross to the collective.
+      package: () => `(package: the-package-name)`,
+      component: () => `(component: The Component)`,
+      aids: (ref) => `(aids:[${ref}])`,
+      // SOLUTION-STRUCTURE (SS-structure) — taught in the link bullet; Solution→Solution.
+      buildsOn: (ref) => `(builds-on:[${ref}])`,
+      supersedes: (ref) => `(supersedes:[${ref}])`,
+      alternative: (ref) => `(alternative:[${ref}])`,
+      // VERDICT (VS-verdict-tags) — a judgment on a SHOWN prior, distinct from leaning on it.
+      // `confirm` rides the corroborate channel (it held); `refute` the contradict channel
+      // (it's wrong / didn't hold) and REQUIRES a reason. This is the inline producer the
+      // evidence channels lacked — refute sat dead (contradictionPressure 0) until now, while
+      // lean-on corroboration lived, because only corroboration had an inline path. Grammar
+      // single-sourced with parseInlineTags' CONFIRM_PREFIX/REFUTE_PREFIX.
+      confirm: (ref) => `(confirm:[${ref}])`,
+      refute: (ref) => `(refute:[${ref}] one line why)`,
+      // RETRACT — "not a real problem": the errata-resolved block with a disposition
+      // (parseDesignResolutions, turn.ts). No inline form exists; the block is the grammar.
+      retract: (id) => ["```errata-resolved", `id: ${id}`, "disposition: false_positive", "reason: why it was never a real problem", "```"].join("\n")
+    };
+    P = "Problem";
+    S = "Solution";
+    RC = "RootCause";
+    CITE_LOWERING = [
+      { target: RC, writes: [{ from: P, edge: "CAUSED_BY", to: RC }] },
+      { target: S, writes: [{ from: P, edge: "SOLVED_BY", to: S }] },
+      { target: "Pattern", writes: [{ from: P, edge: "INSTANCE_OF", to: "Pattern" }, { from: "Pattern", edge: "ANCHORED_AT", to: "File" }], note: "cite-anchor promotion after 2 sessions", decision: "d", knownViolation: { edge: "ANCHORED_AT", finding: "motif cite-anchor promotion writes a refused ANCHORED_AT" } },
+      { target: "Package", writes: [{ from: P, edge: "DEPENDS_ON", to: "Package" }] },
+      { target: "Language", writes: [{ from: P, edge: "OCCURS_IN", to: "Language" }] },
+      { target: "Tool", writes: [{ from: P, edge: "CONCERNS", to: "Tool" }] },
+      { target: "Component", writes: [{ from: P, edge: "CONCERNS", to: "Component" }] },
+      { target: P, writes: [{ from: P, edge: "RELATES_TO", to: P }, { from: P, edge: "ANCHORED_AT", to: "File" }], note: "corroboration witness + cite-anchor promotion" },
+      { target: "AntiPattern", writes: [{ from: P, edge: "RELATES_TO", to: "AntiPattern" }, { from: "AntiPattern", edge: "ANCHORED_AT", to: "File" }], decision: "e", knownViolation: { edge: "ANCHORED_AT", finding: "motif cite-anchor promotion writes a refused ANCHORED_AT" } },
+      { target: "Technique", writes: [{ from: P, edge: "RELATES_TO", to: "Technique" }, { from: "Technique", edge: "ANCHORED_AT", to: "File" }], decision: "e", knownViolation: { edge: "ANCHORED_AT", finding: "motif cite-anchor promotion writes a refused ANCHORED_AT" } },
+      { target: "Weakness", writes: [{ from: P, edge: "RELATES_TO", to: "Weakness" }], decision: "e" },
+      { target: "Domain", writes: [{ from: P, edge: "RELATES_TO", to: "Domain" }], decision: "e" },
+      { target: "Claim", writes: [{ from: P, edge: "RELATES_TO", to: "Claim" }, { from: "Claim", edge: "ANCHORED_AT", to: "File" }] }
+    ];
+    INSTANCE_LOWERING = [
+      { target: "Pattern", writes: [{ from: P, edge: "INSTANCE_OF", to: "Pattern" }] },
+      { target: P, writes: [{ from: P, edge: "RELATES_TO", to: P }] },
+      { target: S, writes: [{ from: P, edge: "SOLVED_BY", to: S }], note: "an instance cite on a Solution claims the problem is solved by it", decision: "a" },
+      { target: RC, writes: [{ from: P, edge: "CAUSED_BY", to: RC }] },
+      { target: "AntiPattern", writes: [{ from: P, edge: "RELATES_TO", to: "AntiPattern" }], decision: "e" },
+      { target: "Technique", writes: [{ from: P, edge: "RELATES_TO", to: "Technique" }], decision: "e" },
+      { target: "Weakness", writes: [{ from: P, edge: "RELATES_TO", to: "Weakness" }], decision: "e" },
+      { target: "Domain", writes: [{ from: P, edge: "RELATES_TO", to: "Domain" }], decision: "e" },
+      { target: "Package", writes: [{ from: P, edge: "DEPENDS_ON", to: "Package" }] },
+      { target: "Component", writes: [{ from: P, edge: "CONCERNS", to: "Component" }] }
+    ];
+    TRIAGE_TO_RC = [
+      { from: P, edge: "TRIAGED_BY", to: "Triage" },
+      { from: "Triage", edge: "INDICATES", to: RC },
+      { from: P, edge: "CAUSED_BY", to: RC }
+    ];
+    TAG_VERBS = [
+      {
+        verb: "cite",
+        form: "citation",
+        opener: "(",
+        kinds: ["prior"],
+        args: "handles",
+        thread: false,
+        handleRequired: true,
+        lowering: CITE_LOWERING,
+        examples: ["prior"],
+        hint: "cite a shown prior you leaned on: ([its-handle]) \u2014 handles only, no prose inside the parens",
+        taught: "taught"
+      },
+      {
+        verb: "!",
+        form: "flag",
+        opener: "[!",
+        kinds: ["problem", "triage", "vulnerability", "fix", "prior"],
+        args: "flag-body",
+        thread: true,
+        minText: 8,
+        qualifiers: [
+          { name: "vuln", taught: true, note: "[!vuln: \u2026] \u2192 Vulnerability (asserted)" },
+          { name: "fixed", taught: false, note: "[!fixed: X] \u2192 read as a self-found fix" },
+          { name: "resolved", taught: false, note: "[!resolved: X] \u2192 read as a self-found fix" }
+        ],
+        lowering: [
+          { target: P, writes: [], note: "mints a Problem; `@ path[:line]` anchors it (ANCHORED_AT to code)" },
+          { target: RC, writes: [...TRIAGE_TO_RC, { from: RC, edge: "CAUSED_BY", to: RC }], note: "`<-` segments: first \u2192 triage route, later \u2192 RootCause chain" },
+          { target: "Vulnerability", writes: [], note: "[!vuln: \u2026]; `<-` causes stay on the finding (vulnerabilityCauses)" }
+        ],
+        examples: ["problem", "problemThread", "vulnerability", "vulnerabilityThread"],
+        hint: "flag a problem on one line: [!what's wrong @ path:42]; fold causes with <- ; a fix goes in (fix: \u2026), not [!fixed: \u2026]",
+        taught: "taught"
+      },
+      {
+        verb: "?",
+        form: "flag",
+        opener: "[?",
+        kinds: ["todo", "vulnerability"],
+        args: "flag-body",
+        thread: true,
+        minText: 8,
+        qualifiers: [{ name: "vuln", taught: true, note: "[?vuln: \u2026] \u2192 Vulnerability (suspected)" }],
+        lowering: [{ target: P, writes: [], note: "mints a todo Problem; a fix can close it today", decision: "g" }],
+        examples: ["suspectedVulnerability"],
+        hint: "[?\u2026] marks an open question / todo; [?vuln: consequence; missing check] a suspected vulnerability",
+        taught: "untaught",
+        taughtBy: "only the [?vuln:] form is taught; the bare [?todo] form is not",
+        decisions: ["g"]
+      },
+      {
+        verb: "fix",
+        form: "verb",
+        opener: "(fix:",
+        kinds: ["fix"],
+        args: "handles-text",
+        thread: true,
+        minText: 12,
+        lowering: [
+          { target: P, writes: [{ from: P, edge: "SOLVED_BY", to: S }], note: "closes the Problem; a note \u226512 chars mints the Solution" },
+          { target: "Vulnerability", writes: [{ from: "Vulnerability", edge: "SOLVED_BY", to: S }] },
+          { target: RC, writes: [], note: "dropped: 'fix tag went nowhere' (not a Problem); no tag writes FIXED_BY", decision: "f" }
+        ],
+        examples: ["fix", "fixThread"],
+        hint: "one fix per tag: (fix:[its-handle]) or (fix:#thread what you changed) \u2014 put the cause in its own (cause: \u2026)",
+        taught: "taught",
+        decisions: ["f"]
+      },
+      {
+        verb: "cause",
+        form: "verb",
+        opener: "(cause:",
+        kinds: ["triage"],
+        args: "handles-text",
+        thread: true,
+        minText: 8,
+        lowering: [
+          { target: RC, writes: TRIAGE_TO_RC },
+          { target: P, writes: [{ from: P, edge: "TRIAGED_BY", to: "Triage" }, { from: "Triage", edge: "INDICATES", to: RC }, { from: P, edge: "CAUSED_BY", to: RC }], note: "(cause:[problem] mechanism) \u2014 the cited Problem is the symptom; the mechanism mints the RootCause" },
+          { target: S, writes: [{ from: P, edge: "TRIAGED_BY", to: "Triage" }, { from: "Triage", edge: "INDICATES", to: S }], decision: "b", knownViolation: { edge: "INDICATES", finding: "(cause:[solution]) writes a refused INDICATES \u2192 Solution" } }
+        ],
+        examples: ["triage", "triageExplain", "triageMint", "causeThread"],
+        hint: "(cause: the mechanism you'd change) or (cause:[root-cause-handle]); bind a distant symptom with (cause:#thread \u2026)",
+        taught: "taught",
+        decisions: ["b"]
+      },
+      {
+        verb: "constraint",
+        form: "verb",
+        opener: "(constraint:",
+        kinds: ["constraint"],
+        args: "text",
+        thread: false,
+        minText: 8,
+        textRequired: true,
+        lowering: [{ target: P, writes: [], note: "mints a constraint-kind Problem" }],
+        examples: ["constraint"],
+        hint: "(constraint: the limitation that forced the decision)",
+        taught: "taught"
+      },
+      {
+        verb: "tried",
+        form: "verb",
+        opener: "(tried:",
+        kinds: ["attempt"],
+        args: "text",
+        thread: true,
+        minText: 8,
+        textRequired: true,
+        lowering: [{ target: P, writes: [], note: "journals an attempt on the bound problem" }],
+        examples: ["tried"],
+        hint: "(tried: the approach) \u2014 bind with (tried:#thread \u2026)",
+        taught: "taught"
+      },
+      {
+        verb: "failed",
+        form: "verb",
+        opener: "(failed:",
+        kinds: ["failure"],
+        args: "handles-text",
+        thread: true,
+        minText: 8,
+        textRequired: true,
+        lowering: [
+          { target: P, writes: [], note: "journals a failed attempt on the bound problem" },
+          { target: S, writes: [], note: "(failed:[h]) refutes the cited prior (contradictionPressure); skips the label gate today", decision: "j" }
+        ],
+        examples: ["failed", "failedCite"],
+        hint: "(failed: what didn't work); (failed:[solution] what came back) refutes a shown fix",
+        taught: "taught",
+        decisions: ["j"]
+      },
+      {
+        verb: "instance",
+        form: "verb",
+        opener: "(instance:",
+        kinds: ["instance"],
+        args: "handles",
+        thread: false,
+        handleRequired: true,
+        lowering: INSTANCE_LOWERING,
+        examples: ["instance"],
+        hint: "(instance:[h1],[h2],[h3]) \u2014 ~3 DIFFERENT shown priors this problem instantiates; handles only",
+        taught: "taught",
+        decisions: ["a", "e"]
+      },
+      {
+        verb: "pattern",
+        form: "verb",
+        opener: "(pattern:",
+        kinds: ["pattern"],
+        args: "handle-or-text",
+        thread: false,
+        minText: 3,
+        lowering: [{ target: "Pattern", writes: [{ from: P, edge: "INSTANCE_OF", to: "Pattern" }], note: "a handle must be a Pattern; free text resolves-or-mints one" }],
+        examples: ["pattern"],
+        hint: "(pattern: name the general shape) or (pattern:[shown-pattern])",
+        taught: "taught"
+      },
+      {
+        verb: "domain",
+        form: "verb",
+        opener: "(domain:",
+        kinds: ["domain"],
+        args: "text",
+        thread: false,
+        minText: 2,
+        textRequired: true,
+        lowering: [{ target: "Domain", writes: [{ from: P, edge: "PERTAIN_TO", to: "Domain" }], note: '(domain:#t X) mints a Domain named "#t X" today', decision: "k" }],
+        examples: ["domain"],
+        hint: "(domain: The Area) \u2014 Title Case, no thread",
+        taught: "taught",
+        decisions: ["k"]
+      },
+      {
+        verb: "package",
+        form: "verb",
+        opener: "(package:",
+        kinds: ["package"],
+        args: "text",
+        thread: false,
+        minText: 2,
+        textRequired: true,
+        lowering: [{ target: "Package", writes: [{ from: P, edge: "DEPENDS_ON", to: "Package" }], note: "means 'concerns', written as DEPENDS_ON", decision: "c" }],
+        examples: ["package"],
+        hint: "(package: the-package-name) \u2014 the public package it's about",
+        taught: "taught",
+        decisions: ["c"]
+      },
+      {
+        verb: "component",
+        form: "verb",
+        opener: "(component:",
+        kinds: ["component"],
+        args: "text",
+        thread: false,
+        minText: 2,
+        textRequired: true,
+        lowering: [{ target: "Component", writes: [{ from: P, edge: "CONCERNS", to: "Component" }] }],
+        examples: ["component"],
+        hint: "(component: The Component) \u2014 the framework/product unit",
+        taught: "taught"
+      },
+      {
+        verb: "aids",
+        form: "verb",
+        opener: "(aids:",
+        kinds: ["transfer"],
+        args: "handles",
+        thread: true,
+        handleRequired: true,
+        lowering: [{ target: P, writes: [{ from: S, edge: "MAY_RESOLVE", to: P }], note: "source = the Solution in scope; non-Problem targets are skipped" }],
+        examples: ["aids"],
+        hint: "(aids:[problem-handle],\u2026) \u2014 other shown problems your fix might also resolve",
+        taught: "taught"
+      },
+      {
+        verb: "builds-on",
+        form: "verb",
+        opener: "(builds-on:",
+        kinds: ["builds-on"],
+        args: "handles",
+        thread: true,
+        handleRequired: true,
+        lowering: [{ target: S, writes: [{ from: S, edge: "BUILDS_ON", to: S }] }],
+        examples: ["buildsOn"],
+        hint: "(builds-on:[shown-solution]) \u2014 your fix layers on it",
+        taught: "taught",
+        taughtBy: "linkBullet instruction text"
+      },
+      {
+        verb: "supersedes",
+        form: "verb",
+        opener: "(supersedes:",
+        kinds: ["supersedes"],
+        args: "handles",
+        thread: true,
+        handleRequired: true,
+        lowering: [{ target: S, writes: [{ from: S, edge: "SUPERSEDES", to: S }] }],
+        examples: ["supersedes"],
+        hint: "(supersedes:[shown-solution]) \u2014 your fix replaces it",
+        taught: "taught",
+        taughtBy: "linkBullet instruction text"
+      },
+      {
+        verb: "alternative",
+        form: "verb",
+        opener: "(alternative:",
+        kinds: ["alternative"],
+        args: "handles",
+        thread: true,
+        handleRequired: true,
+        lowering: [{ target: S, writes: [{ from: S, edge: "ALTERNATIVE_TO", to: S }] }],
+        examples: ["alternative"],
+        hint: "(alternative:[shown-solution]) \u2014 a different valid approach",
+        taught: "taught",
+        taughtBy: "linkBullet instruction text"
+      },
+      {
+        verb: "confirm",
+        form: "verb",
+        opener: "(confirm:",
+        kinds: ["confirm"],
+        args: "handles",
+        thread: false,
+        handleRequired: true,
+        lowering: [{ target: S, writes: [], note: "corroboration witness (corroborationCount), no edge" }],
+        examples: ["confirm"],
+        hint: "(confirm:[shown-prior]) \u2014 it held",
+        taught: "taught",
+        taughtBy: "verdictBullet + context render",
+        decisions: ["j"]
+      },
+      {
+        verb: "refute",
+        form: "verb",
+        opener: "(refute:",
+        kinds: ["refute"],
+        args: "handles-text",
+        thread: false,
+        minText: 4,
+        handleRequired: true,
+        textRequired: true,
+        lowering: [{ target: S, writes: [], note: "contradiction witness (contradictionPressure), no edge; reason stays local" }],
+        examples: ["refute"],
+        hint: "(refute:[shown-prior] one line why) \u2014 the reason is required",
+        taught: "taught",
+        taughtBy: "verdictBullet + context render",
+        decisions: ["j"]
+      }
+    ];
+    TAG_FENCES = [
+      {
+        fence: "errata-problem",
+        fields: ["problem", "cause", "fix", "anchor", "kind"],
+        required: [["problem"]],
+        taught: "untaught",
+        parser: "apps/daemon/src/turn.ts parseDesignFlags",
+        decisions: ["h"],
+        hint: "use an inline [!\u2026] flag instead (errata-problem cause ids never meet inline ids)"
+      },
+      {
+        fence: "errata-resolved",
+        fields: ["id", "problem", "fix", "disposition", "reason"],
+        required: [["id", "problem"]],
+        taught: "taught",
+        taughtBy: "retract form only (TAG_EXAMPLE.retract); the fix form is untaught",
+        parser: "apps/daemon/src/turn.ts parseDesignResolutions",
+        hint: "```errata-resolved with id: and disposition: false_positive | invalid, reason: \u2026"
+      },
+      {
+        fence: "errata-triage",
+        fields: ["presenting", "cause", "test", "fix", "drift", "route"],
+        required: [["presenting", "route"], ["cause", "test"]],
+        taught: "taught",
+        taughtBy: "MCP errata_triage tool copy",
+        parser: "packages/local-graph/src/triage.ts parseTriageFences",
+        hint: "```errata-triage with presenting: and cause: (or route: + test: to answer one)"
+      },
+      {
+        fence: "errata-abstraction",
+        fields: ["candidate", "principle", "covers"],
+        required: [["candidate"], ["principle"], ["covers"]],
+        taught: "taught",
+        taughtBy: "MCP errata_pending_abstractions tool copy",
+        parser: "packages/local-graph/src/abstraction.ts parseAbstractionFences",
+        hint: "```errata-abstraction with candidate:, principle:, covers: (all required)"
+      },
+      {
+        fence: "errata-intent",
+        fields: ["intent"],
+        required: [["intent"]],
+        taught: "taught",
+        parser: "packages/local-graph/src/intent.ts parseIntentFences",
+        hint: "```errata-intent with intent: what you're about to do"
+      },
+      {
+        fence: "errata-share",
+        fields: ["priors"],
+        required: [["priors"]],
+        taught: "taught",
+        taughtBy: "subagent hand-off copy",
+        parser: "packages/local-graph/src/intent.ts parseShareFence",
+        hint: "```errata-share with priors: all | [h1], [h2]"
+      }
+    ];
+    TAG_VERB_BY_NAME = new Map(
+      TAG_VERBS.filter((v) => v.form === "verb").map((v) => [v.verb, v])
+    );
+    TAG_PAREN_VERBS = [...TAG_VERB_BY_NAME.keys()].sort((a, b) => b.length - a.length);
+    TAG_GRAMMAR_OPENERS = [
+      ...new Set(TAG_VERBS.filter((v) => v.form !== "citation").map((v) => v.opener))
+    ];
+    TAG_QUOTED_PAREN_SOURCE = String.raw`\(\s*(?:${TAG_PAREN_VERBS.map((v) => v.replace(/-/g, "\\-")).join("|")})\s*:|\(\[`;
+    TAG_QUOTED_RE = new RegExp(String.raw`\[[!?]|` + TAG_QUOTED_PAREN_SOURCE, "i");
+    TAG_QUOTED_PAREN_RE = new RegExp(TAG_QUOTED_PAREN_SOURCE, "i");
+    TEMPLATE_VERB_GROUP = new RegExp(
+      String.raw`\(\s*(${TAG_PAREN_VERBS.map((v) => v.replace(/-/g, "\\-")).join("|")})\s*:((?:[^()\n]|\([^()\n]*\))*)\)`,
+      "gi"
+    );
+    BRACKET_TOKEN = /\[([^\]\n]{1,80})\]/g;
+    REAL_HANDLE_SHAPE = new RegExp(
+      String.raw`^(?:[a-z0-9]+(?:-[a-z0-9]+)*-(?=[0-9a-f]{0,3}\d)[0-9a-f]{4}|(?:${TAG_CANONICAL_ID_PREFIXES.join("|")})_[0-9a-f]{6,})$`,
+      "i"
+    );
+    TAG_TEMPLATES = deriveTagTemplates(tagGrammarCopy());
+    VERB_WORDS_SOURCE = TAG_PAREN_VERBS.map((v) => v.replace(/-/g, "\\-")).join("|");
+    JOINED_VERB = new RegExp(String.raw`[,;]\s*(?=(?:${VERB_WORDS_SOURCE})\s*:)`, "i");
+    LEADING_VERB = new RegExp(String.raw`^\s*(${VERB_WORDS_SOURCE})\s*:`, "i");
+    ANY_VERB_WORD = new RegExp(String.raw`\b(?:${VERB_WORDS_SOURCE})\s*:`, "gi");
+    QUOTED_TAG_OPENER = new RegExp(String.raw`\(\s*(?:(${VERB_WORDS_SOURCE})\s*:|(?=\[))`, "gi");
+    TAG_VERDICT_TOKENS = {
+      confirm: (id) => TAG_EXAMPLES.confirm(id),
+      refute: (id) => TAG_EXAMPLES.refute(id),
+      failed: (id) => TAG_EXAMPLES.failedCite(id)
+    };
+  }
+});
+
 // ../../packages/local-shared/src/index.ts
 var init_src2 = __esm({
   "../../packages/local-shared/src/index.ts"() {
@@ -18218,6 +18817,7 @@ var init_src2 = __esm({
     init_review();
     init_anchorable();
     init_sqlite_adapter();
+    init_tag_grammar();
   }
 });
 
@@ -20854,6 +21454,20 @@ CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_ty
         if (revived > 0) this.mutations++;
         return revived;
       }
+      incomingEdgeCoverage(label, edgeTypes, cloudOnly) {
+        if (edgeTypes.length === 0) return { count: 0, total: 0 };
+        const r = this.db.prepare(
+          `SELECT COUNT(*) AS total,
+                COALESCE(SUM(CASE WHEN EXISTS (
+                  SELECT 1 FROM edges e WHERE e.to_id = n.id AND e.valid_to IS NULL
+                    AND e.type IN (${edgeTypes.map(() => "?").join(",")})
+                ) THEN 1 ELSE 0 END), 0) AS count
+           FROM nodes n
+          WHERE n.label = ? AND n.valid_to IS NULL
+            AND (? = 0 OR json_extract(n.attrs_json, '$.source') = 'cloud')`
+        ).get(...edgeTypes, label, cloudOnly ? 1 : 0);
+        return { count: Number(r.count), total: Number(r.total) };
+      }
       recentEdgeAttrCoverage(marker, attr, limit) {
         const r = this.db.prepare(
           `SELECT COUNT(*) AS total,
@@ -25739,6 +26353,14 @@ var init_principle_sync = __esm({
 
 // ../../packages/local-graph/src/mechanism-liveness.ts
 function evaluateFed(store, d) {
+  if (d.fedIncoming) {
+    const { count: count2, total } = store.incomingEdgeCoverage?.(
+      d.fedIncoming.label,
+      d.fedIncoming.edgeTypes,
+      d.fedIncoming.cloudOnly
+    ) ?? { count: 0, total: 0 };
+    return { count: count2, total, fraction: total === 0 ? 0 : count2 / total };
+  }
   if (d.fedEdges) {
     const { count: count2, total } = store.recentEdgeAttrCoverage(
       d.fedEdges.marker,
@@ -25790,7 +26412,7 @@ function evaluateMechanisms(store, invocations = /* @__PURE__ */ new Map(), mech
     if (d.configCounter && inv?.lastTotals?.[d.configCounter] === 0) verdict = "unconfigured";
     else if ((backlog ?? 0) === 0 && (!hasInput && !d.inputOptional || missingRequiredNodes)) verdict = "no-input";
     else if (!inv || inv.runs === 0) verdict = "never-invoked";
-    else if (fed.fraction < (d.fedEdges?.minFraction ?? d.fed?.minFraction ?? 0)) verdict = "starved";
+    else if (fed.fraction < minFractionOf(d)) verdict = "starved";
     else if (stalled) verdict = "stalled";
     else if (effectCount === 0) verdict = "no-effect";
     else verdict = "ok";
@@ -25801,7 +26423,7 @@ function evaluateMechanisms(store, invocations = /* @__PURE__ */ new Map(), mech
       fedCount: fed.count,
       fedTotal: fed.total,
       fedFraction: fed.fraction,
-      minFraction: d.fedEdges?.minFraction ?? d.fed?.minFraction ?? 0,
+      minFraction: minFractionOf(d),
       ...inv ? { lastInvokedMs: inv.lastTs } : {},
       runs: inv?.runs ?? 0,
       effectCount,
@@ -25813,6 +26435,9 @@ function evaluateMechanisms(store, invocations = /* @__PURE__ */ new Map(), mech
     };
   });
 }
+function minFractionOf(d) {
+  return d.fedIncoming?.minFraction ?? d.fedEdges?.minFraction ?? d.fed?.minFraction ?? 0;
+}
 function formatMechanismStatus(rows, nowMs) {
   return rows.map((r) => {
     const pct = (r.fedFraction * 100).toFixed(r.fedFraction < 0.01 ? 2 : 1);
@@ -26099,6 +26724,25 @@ var init_mechanism_liveness = __esm({
         // reading is IDLE — correct, and it declares no backlog on purpose.
         effectCounter: "alarms",
         note: "steady-state IDLE is healthy; the row exists for its invocation age"
+      },
+      {
+        id: "project-causal-sync",
+        what: "lands the cloud project stratum's SOLVED_BY/FIXED_BY edges onto the knowledge the anchor feed mirrors",
+        // PRODUCER: the anchor feed's causal leg — `fetchProjectAnchors` returns the
+        // edges, `syncProjectAnchors` (apps/daemon/src/project-reanchor.ts) lands or
+        // parks them, on the `anchor-pull` beat. CONSUMERS: every local walk that
+        // crosses Problem→Solution — errata_trace/why/burst over the store, and the
+        // passive priming block that renders a problem with its fix. Before
+        // PJ-sync-causal the feed mirrored 5,054 cloud Solutions on the dev checkout
+        // with not one incoming SOLVED_BY: this row would have read 0.0% for months.
+        pass: "anchor-pull",
+        fedIncoming: { label: "Solution", edgeTypes: ["SOLVED_BY", "FIXED_BY"], cloudOnly: true, minFraction: 0.5 },
+        effectCounter: "edgesLanded",
+        // Parked edges waiting on an endpoint — a flat, non-zero backlog is a stratum
+        // whose other ends never arrive here (a cap, or a gate that refuses them).
+        backlogCounter: "edgesPending",
+        requiresNodes: ["Problem"],
+        note: "an orphaned cloud Solution reads as a fix with no problem; the one-time causal re-walk lifts this after the server ships the leg"
       }
     ];
     COLUMN_INPUTS = {
@@ -26743,7 +27387,7 @@ function renderSnapshot(s) {
         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)`
+            `  - the fix on record: ${g.solution.description.slice(0, 120)} \u2014 \`${g.solution.id}\` \xB7 fix still holds \u2192 ${TAG_VERDICT_TOKENS.confirm(g.solution.id)} \xB7 hitting it again \u2192 flag it (a second independent witness reopens the close)`
           );
         } else {
           lines.push(
@@ -26840,7 +27484,7 @@ function renderSnapshot(s) {
             `  - still open \u2014 did this work settle it? fixed \u2192 (fix:[${h.id}]) \xB7 not a real problem \u2192 an \`errata-resolved\` block with \`id: ` + h.id + "`, `disposition: false_positive`, `reason: \u2026` \xB7 still open \u2192 say nothing"
           );
         } else if (h.verdict === "foreign") {
-          lines.push(`  - open in another membrane \u2014 not yours to close: (confirm:[${h.id}]) it held \xB7 (refute:[${h.id}] one line why)`);
+          lines.push(`  - open in another membrane \u2014 not yours to close: ${TAG_VERDICT_TOKENS.confirm(h.id)} it held \xB7 ${TAG_VERDICT_TOKENS.refute(h.id)}`);
         }
       }
     }
@@ -26911,7 +27555,7 @@ function renderSnapshot(s) {
         lines.push(`  - \u2713 ${p.description}`);
         for (const s2 of w.priors.solutionsByProblem[p.id] ?? []) {
           lines.push(
-            `    - fixed by: ${s2.description} \u2014 if that fix did NOT hold, refute it: \`(failed:[${s2.id}] what came back)\``
+            `    - fixed by: ${s2.description} \u2014 if that fix did NOT hold, refute it: \`${TAG_VERDICT_TOKENS.failed(s2.id)}\``
           );
         }
       }
@@ -28396,7 +29040,7 @@ var init_client = __esm({
           "GET",
           `/v2/projects/${encodeURIComponent(projectId)}/anchors?since=${String(Math.max(0, Math.floor(since)))}&limit=${String(limit)}`
         );
-        const { nodes } = this.toCastalia({ nodes: res.nodes ?? [], edges: [] });
+        const { nodes, edges } = this.toCastalia({ nodes: res.nodes ?? [], edges: res.edges ?? [] });
         const anchors = (res.anchors ?? []).map((a) => ({
           from: a.fromCanonicalId,
           toSymbolId: a.toSymbolId,
@@ -28404,7 +29048,7 @@ var init_client = __esm({
           attrs: a.attrs ?? {},
           stampedAt: typeof a.stampedAt === "number" ? a.stampedAt : 0
         }));
-        return { nodes, anchors, cursor: typeof res.cursor === "number" ? res.cursor : since };
+        return { nodes, edges, causalLeg: Array.isArray(res.edges), anchors, cursor: typeof res.cursor === "number" ? res.cursor : since };
       }
       /** Pull cloud-induced skills + the session-bootstrap prime payload. `seed` is the
        *  canonical ids of the agent's recent problems — the cloud ranks the skills whose
@@ -33885,7 +34529,7 @@ function linkBullet(ref) {
     `    \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`
+    `    \xB7 your fix vs a shown solution: ${TAG_EXAMPLE.buildsOn(ref)} \xB7 ${TAG_EXAMPLE.supersedes(ref)} \xB7 ${TAG_EXAMPLE.alternative("h")} \u2014 pick one`
   ].join("\n");
 }
 function verdictBullet(ref) {
@@ -33916,75 +34560,13 @@ function buildAgentInstruction(opts = {}) {
     tail
   ].join("\n");
 }
-var TAG_EXAMPLE, TAG_OPENERS, GLOSS;
+var TAG_EXAMPLE, TAG_OPENERS, GLOSS, ALL_SIGNALS, TAG_TEMPLATES2;
 var init_agent_signals = __esm({
   "src/agent-signals.ts"() {
     "use strict";
-    TAG_EXAMPLE = {
-      prior: (ref) => `([${ref}])`,
-      problem: () => `[!one line on what's wrong]`,
-      vulnerability: () => `[!vuln: who can do what; observed basis @ path:line]`,
-      suspectedVulnerability: () => `[?vuln: consequence; missing check]`,
-      vulnerabilityThread: () => `[!#v vuln: finding here]`,
-      fix: (ref) => `(fix:[${ref}])`,
-      // CONSTRAINT — the native capture path for a DIFFUSE problem (a constraint/tension/
-      // conflict that shaped a decision). Free text, attaches to the decision sentence the
-      // agent is already writing. Full rationale in the constraint note below + prior-tags.ts.
-      constraint: () => `(constraint: the limitation that forced it)`,
-      // TRIAGE — routes the problem/symptom in scope to its cause. `(cause:[handle])`
-      // links to a cited RootCause/Solution node; `(cause: free text)` mints a RootCause
-      // from the text. Harvested in prior-tags.ts → engine.ts (see the triage note below).
-      triage: (ref) => `(cause:[${ref}])`,
-      // Unlike a bare cause citation, this handle names the Problem being explained.
-      triageExplain: (ref) => `(cause:[${ref}] the mechanism)`,
-      // The MINT form — free-text cause that mints a RootCause. Prime-time surfacing
-      // (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)`,
-      // 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: (thread = "slug") => `(fix:#${thread} 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)`,
-      // LINK verbs (AC epic) — bind the problem in scope to CANONICAL priors and
-      // abstractions. Multi-target by design: single links are weak; ~3 links to 3
-      // DIFFERENT relevant priors is the target shape (see linkBullet).
-      instance: (ref) => `(instance:[${ref}],[another],[a-third])`,
-      pattern: () => `(pattern: name the general shape)`,
-      // DOMAIN — the abstract area a problem is about; the concept layer an
-      // anchor-less problem clusters on. Mints/resolves a Domain by name.
-      domain: () => `(domain: The Area)`,
-      // PACKAGE/COMPONENT — agent-named public anchors (OM-agent-anchors): the
-      // package a problem is ABOUT (even when not a dependency) and the
-      // framework/product-level unit it concerns. Public spine anchors → the
-      // knowledge can cross to the collective.
-      package: () => `(package: the-package-name)`,
-      component: () => `(component: The Component)`,
-      aids: (ref) => `(aids:[${ref}])`,
-      // VERDICT (VS-verdict-tags) — a judgment on a SHOWN prior, distinct from leaning on it.
-      // `confirm` rides the corroborate channel (it held); `refute` the contradict channel
-      // (it's wrong / didn't hold) and REQUIRES a reason. This is the inline producer the
-      // evidence channels lacked — refute sat dead (contradictionPressure 0) until now, while
-      // lean-on corroboration lived, because only corroboration had an inline path. Grammar
-      // single-sourced with parseInlineTags' CONFIRM_PREFIX/REFUTE_PREFIX.
-      confirm: (ref) => `(confirm:[${ref}])`,
-      refute: (ref) => `(refute:[${ref}] one line why)`,
-      // RETRACT — "not a real problem": the errata-resolved block with a disposition
-      // (parseDesignResolutions, turn.ts). No inline form exists; the block is the grammar.
-      retract: (id) => ["```errata-resolved", `id: ${id}`, "disposition: false_positive", "reason: why it was never a real problem", "```"].join("\n")
-    };
-    TAG_OPENERS = [
-      ...new Set(
-        Object.values(TAG_EXAMPLE).map((example) => /^(\([a-z][\w-]*:|\[[!?])/i.exec(example("x"))?.[1]?.toLowerCase()).filter((opener) => opener !== void 0)
-      )
-    ];
+    init_src2();
+    TAG_EXAMPLE = TAG_EXAMPLES;
+    TAG_OPENERS = TAG_GRAMMAR_OPENERS;
     GLOSS = {
       prior: "a shown prior helped, or you work in a primed language/package",
       // "even in code you just wrote" names the implementation phase explicitly. Field
@@ -34021,6 +34603,12 @@ var init_agent_signals = __esm({
       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",
       verdict: "you can judge a prior we SHOWED you \u2014 confirm it if it held, refute it (with why) if it didn't; rendered whole via verdictBullet"
     };
+    ALL_SIGNALS = ["prior", "problem", "vulnerability", "domain", "fix", "constraint", "triage", "attempt", "link", "verdict"];
+    TAG_TEMPLATES2 = deriveTagTemplates([
+      ...tagGrammarCopy(),
+      ...["its-handle", "its-id"].map((referent) => buildAgentInstruction({ signals: ALL_SIGNALS, referent })),
+      buildFileRecallInstruction()
+    ]);
   }
 });
 
@@ -75835,8 +76423,8 @@ var init_report_render = __esm({
 
 // src/cli.ts
 init_src6();
-import { closeSync as closeSync3, existsSync as existsSync40, openSync as openSync3, readFileSync as readFileSync42, renameSync as renameSync7, statSync as statSync13 } from "node:fs";
-import { join as join49, resolve as pathResolve2 } from "node:path";
+import { closeSync as closeSync3, existsSync as existsSync40, openSync as openSync3, readFileSync as readFileSync43, renameSync as renameSync8, statSync as statSync13 } from "node:fs";
+import { join as join50, resolve as pathResolve2 } from "node:path";
 import { spawn as spawn5 } from "node:child_process";
 
 // src/daemon.ts
@@ -77301,9 +77889,9 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname17 = sysPath.dirname(file2);
+    const dirname18 = sysPath.dirname(file2);
     const basename10 = sysPath.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname17);
+    const parent = this.fsw._getWatchedDir(dirname18);
     let prevStats = stats;
     if (parent.has(basename10))
       return;
@@ -77330,7 +77918,7 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error48) {
-          this.fsw._remove(dirname17, basename10);
+          this.fsw._remove(dirname18, basename10);
         }
       } else if (parent.has(basename10)) {
         const at = newStats.atimeMs;
@@ -79560,26 +80148,14 @@ init_src5();
 import { readFileSync as readFileSync18, writeFileSync as writeFileSync14 } from "node:fs";
 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_RE2 = /\[([a-z0-9][\w-]{0,80})\]|((?:pat|sol|drc|dcause|dfix|dprob|dvuln|prob|claim|err)_[0-9a-f]{6,})/gi;
-var PLACEHOLDER_HANDLES = /* @__PURE__ */ new Set([
-  "handle",
-  "its-handle",
-  "another",
-  "a-third",
-  "h",
-  "h1",
-  "h2",
-  "id",
-  "its-id",
-  "a",
-  "b"
-]);
+var HANDLE_RE2 = new RegExp(TAG_HANDLE_SOURCE, "gi");
+var PLACEHOLDER_HANDLES = TAG_PLACEHOLDER_HANDLES;
 var isPlaceholderHandle = (h) => PLACEHOLDER_HANDLES.has(h.toLowerCase());
 var FLAG_BODY_HANDLE_RE = /^(?:[a-z0-9]+(?:-[a-z0-9]+){2,}-(?=[0-9a-f]{0,3}\d)[0-9a-f]{4}|(?:pat|sol|drc|dcause|dfix|dprob|dvuln|prob|claim|err)_[0-9a-f]{6,})$/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:(?:#([a-z][\w-]{0,63}))?\s*/i;
 var NEST2_UNIT = String.raw`(?:[^()\n]|\((?:[^()\n]|\([^()\n]*\))*\))`;
+var CONSTRAINT_RE = new RegExp(String.raw`\(\s*constraint:\s*(${NEST2_UNIT}{8,}?)\s*\)`, "gi");
 var FIX_LONG_RE = new RegExp(String.raw`\(\s*fix:(?:#([a-z][\w-]{0,63}))?\s*(${NEST2_UNIT}{12,}?)\s*\)`, "gi");
 var CAUSE_LONG_RE = new RegExp(String.raw`\(\s*cause:(?:#([a-z][\w-]{0,63}))?\s*(${NEST2_UNIT}{8,}?)\s*\)`, "gi");
 var CONFIRM_LONG_RE = new RegExp(String.raw`\(\s*confirm:\s*(${NEST2_UNIT}{4,}?)\s*\)`, "gi");
@@ -79595,7 +80171,7 @@ var BRACKETED_TOKEN_RE = /\[[^\]\n]{1,120}\]/;
 var CONFIRM_PREFIX = /^\s*confirm:\s*/i;
 var REFUTE_PREFIX = /^\s*refute:\s*/i;
 var REFUTE_REASON_MIN = 4;
-var PATTERN_RE = /\(\s*pattern:\s*([^()\n]{3,}?)\s*\)/gi;
+var PATTERN_RE = new RegExp(String.raw`\(\s*pattern:\s*(${NEST2_UNIT}{3,}?)\s*\)`, "gi");
 var DOMAIN_RE = /\(\s*domain:\s*([^()\n]{2,}?)\s*\)/gi;
 var PACKAGE_RE = /\(\s*package:\s*([^()\n]{2,}?)\s*\)/gi;
 var COMPONENT_RE = /\(\s*component:\s*([^()\n]{2,}?)\s*\)/gi;
@@ -79688,6 +80264,10 @@ function deriveFixRationale(sentence, startIdx, endIdx) {
   if (before.length >= FIX_RATIONALE_MIN) return before;
   return fixRationaleAfter(sentence, endIdx);
 }
+var TAG_GROUP_OPENER_RE = new RegExp(
+  TAG_OPENERS.filter((o) => o.startsWith("(")).map((o) => String.raw`\(\s*${o.slice(1, -1).replace(/-/g, "\\-")}\s*:`).join("|"),
+  "gi"
+);
 var LEADING_OPENER_RE = new RegExp(String.raw`^(?:${RESIDUAL_OPENER_RE.source})(?:#[a-z][\w-]{0,63})?\s*`, "i");
 var WRAPPER_PAIRS = [["(", ")"], ["[", "]"]];
 var LEADING_HANDLES_RE = /^(?:\[[a-z0-9][\w-]{0,80}\]\s*,?\s*)+/i;
@@ -79826,19 +80406,41 @@ function addTagDispositions(a, b) {
 function parseInlineTags(text) {
   return parseInlineTagsWithDispositions(text).tags;
 }
+function tagGroupSpans(line) {
+  const spans = [];
+  let after = 0;
+  for (const m of line.matchAll(TAG_GROUP_OPENER_RE)) {
+    const start2 = m.index;
+    if (start2 < after) continue;
+    let depth = 0;
+    const limit = Math.min(line.length, start2 + 4e3);
+    for (let i2 = start2; i2 < limit; i2++) {
+      if (line[i2] === "(") depth++;
+      else if (line[i2] === ")" && --depth === 0) {
+        spans.push({ start: start2, end: i2 + 1 });
+        after = i2 + 1;
+        break;
+      }
+    }
+  }
+  return spans;
+}
 function* captureSentences(text) {
   for (const line of text.split(/\n+/)) {
     if (line.length > 2e4) {
       yield line;
       continue;
     }
-    const flags2 = [...flagScanView(line).matchAll(new RegExp(FLAG_RE.source, FLAG_RE.flags))].map((m) => ({ start: m.index, end: m.index + m[0].length }));
+    const flags2 = [
+      ...[...flagScanView(line).matchAll(new RegExp(FLAG_RE.source, FLAG_RE.flags))].map((m) => ({ start: m.index, end: m.index + m[0].length })),
+      ...tagGroupSpans(line)
+    ].sort((a, b) => a.start - b.start);
     let flag = 0;
     let start2 = 0;
     for (const boundary of line.matchAll(/(?<=[.!?])\s+(?!\(fix:)/g)) {
       const index = boundary.index;
       while (flags2[flag] && flags2[flag].end <= index) flag++;
-      if (flags2[flag] && flags2[flag].start < index) continue;
+      if (flags2.slice(flag).some((f) => f.start < index && index < f.end)) continue;
       yield line.slice(start2, index);
       start2 = index + boundary[0].length;
     }
@@ -79857,22 +80459,28 @@ function parseInlineTagsWithDispositions(text) {
       continue;
     }
     const seqStart = out2.length;
-    const sentence = raw2.replace(/`[^`]*`/g, (m) => {
-      if (!/\[[!?]|\((?:fix|cause|constraint|tried|failed|confirm|refute):|\(\[/.test(m)) return m;
-      if (!/\((?:fix|cause|constraint|tried|failed|confirm|refute):|\(\[/.test(m)) {
+    const original = raw2;
+    const flagView = flagScanView(raw2);
+    const flagSpans = [...flagView.matchAll(new RegExp(FLAG_RE.source, FLAG_RE.flags))].map((m) => [m.index, m.index + m[0].length]);
+    const sentence = raw2.replace(/`[^`]*`/g, (m, at) => {
+      if (!TAG_QUOTED_RE.test(m)) return m;
+      if (!TAG_QUOTED_PAREN_RE.test(m)) {
         dispositions.codeSpanNeutralized++;
         return m;
       }
+      const inFlag = flagSpans.some(([a2, b]) => a2 < at && at < b);
+      if (!inFlag && !/\[[!?]/.test(m) && !quotesOnlyTemplateTags(m, TAG_TEMPLATES2)) return m;
       dispositions.codeSpanNeutralized++;
-      return " ";
+      return m.replace(/[()[\]]/g, " ");
     });
-    const sfield = sentence.replace(/\s+/g, " ").trim().slice(0, 160);
+    const sfield = raw2.replace(/\s+/g, " ").trim().slice(0, 160);
     const citeMatched = /* @__PURE__ */ new Set();
-    const flagSpans = [...flagScanView(sentence).matchAll(new RegExp(FLAG_RE.source, FLAG_RE.flags))].map((m) => [m.index, m.index + m[0].length]);
+    const codeOnly = [...sentence.matchAll(/`[^`]*`/g)].filter((m) => !TAG_QUOTED_PAREN_RE.test(m[0])).map((m) => [m.index, m.index + m[0].length]);
     CITE_GROUP_RE.lastIndex = 0;
     let g;
     while ((g = CITE_GROUP_RE.exec(sentence)) !== null) {
       citeMatched.add(g.index);
+      if (codeOnly.some(([a2, b]) => a2 < g.index && g.index < b)) continue;
       let content = g[1];
       if (/^\s*pattern:/i.test(content)) continue;
       if (/^\s*failed:/i.test(content)) continue;
@@ -79957,6 +80565,7 @@ function parseInlineTagsWithDispositions(text) {
       let h;
       let emittedHandle = false;
       while ((h = HANDLE_RE2.exec(content)) !== null) {
+        if (content[h.index + h[0].length] === "(") continue;
         const handle2 = h[1] ?? h[2];
         if (handle2 && isPlaceholderHandle(handle2)) {
           dispositions.placeholderEcho++;
@@ -80062,10 +80671,9 @@ function parseInlineTagsWithDispositions(text) {
       }
     }
     FLAG_RE.lastIndex = 0;
-    const flagView = flagScanView(sentence);
     let f;
     while ((f = FLAG_RE.exec(flagView)) !== null) {
-      f[3] = sentence.slice(...f.indices[3]);
+      f[3] = original.slice(...f.indices[3]);
       const flagThread = f[2];
       const raw3 = f[3].trim();
       if (/^vuln\b/i.test(raw3)) {
@@ -85224,7 +85832,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.22-dev.4135" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.22-dev.4164" : "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;
@@ -88350,7 +88958,7 @@ function invalidateInstanceReceipt(current, destination, failedId, mirrorLegacy)
 // src/multi.ts
 init_dist();
 init_src5();
-import { existsSync as existsSync34, writeFileSync as writeFileSync26 } from "node:fs";
+import { existsSync as existsSync34, writeFileSync as writeFileSync27 } from "node:fs";
 import { resolve as pathResolve } from "node:path";
 
 // src/principle-sync.ts
@@ -89840,7 +90448,6 @@ function liveCloudClient(src) {
 init_identity2();
 
 // src/project-hydrate.ts
-init_src11();
 init_profile2();
 
 // src/project-reanchor.ts
@@ -89915,6 +90522,62 @@ async function syncHistoryCorrections(opts) {
   }
 }
 
+// src/project-reanchor.ts
+init_paths();
+
+// src/project-sync-landing.ts
+init_src11();
+function landCloudNode(store, n, isOwnTwin) {
+  if (store.getNode(n.id)) return "present";
+  if (isOwnTwin) return "own";
+  store.mergeNode(n);
+  return "landed";
+}
+function landCloudEdge(store, e, from, to) {
+  if (store.outEdges(from, [e.type]).some((x) => x.to === to)) return false;
+  const id = from === e.from && to === e.to ? e.id : edgeId(from, e.type, to);
+  if (store.getEdge(id)) return false;
+  store.mergeEdge({ ...e, id, from, to, attrs: { ...e.attrs, source: "cloud" } });
+  return true;
+}
+
+// src/causal-edge-queue.ts
+import { readFileSync as readFileSync35, renameSync as renameSync5, writeFileSync as writeFileSync25 } from "node:fs";
+import { dirname as dirname13, join as join39 } from "node:path";
+var CAUSAL_EDGE_QUEUE_CAP = 5e3;
+var CAUSAL_EDGE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+function causalEdgeQueuePath(workspaceConfigDir) {
+  return join39(workspaceConfigDir, "causal-edge-queue.json");
+}
+function parkedEdgeKey(e) {
+  return `${e.from}|${e.type}|${e.to}`;
+}
+function loadCausalEdgeQueue(path3) {
+  let raw2;
+  try {
+    raw2 = JSON.parse(readFileSync35(path3, "utf8"));
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(raw2)) return [];
+  return raw2.filter(
+    (p) => !!p && typeof p === "object" && typeof p.ts === "number" && typeof p.edge?.from === "string" && typeof p.edge?.to === "string" && typeof p.edge?.type === "string"
+  );
+}
+function saveCausalEdgeQueue(path3, queue) {
+  try {
+    const tmp = join39(dirname13(path3), `.${Date.now()}.causal-edge-queue.tmp`);
+    writeFileSync25(tmp, JSON.stringify(queue), "utf8");
+    renameSync5(tmp, path3);
+  } catch {
+  }
+}
+function pruneCausalEdgeQueue(queue, now) {
+  const live3 = queue.filter((p) => now - p.ts < CAUSAL_EDGE_TTL_MS);
+  if (live3.length <= CAUSAL_EDGE_QUEUE_CAP) return live3;
+  return [...live3].sort((a, b) => a.ts - b.ts).slice(live3.length - CAUSAL_EDGE_QUEUE_CAP);
+}
+
 // src/project-reanchor.ts
 var DEFAULT_LIMIT = 50;
 var ANCHOR_SYMBOL_KINDS2 = [
@@ -90114,10 +90777,12 @@ async function reanchorProject(opts) {
 }
 var SYNC_PAGE = 200;
 var SYNC_MAX_PAGES = 25;
+var SYNC_EDGE_TYPES = new Set(PROJECT_SYNC_EDGE_TYPES);
 async function syncProjectAnchors(opts) {
   const { root, profile, store, cloud, salt } = opts;
   if (!profile.projectId) return { synced: false, reason: "no-project" };
   const projectId = profile.projectId;
+  const clock = opts.now ?? Date.now;
   const key = `${projectId}|${salt}`;
   const reverse = cachedMap(
     reverseCache,
@@ -90126,23 +90791,95 @@ async function syncProjectAnchors(opts) {
     () => buildReverseSymbolMap({ store, salt, projectId })
   );
   const own = cachedMap(ownCache, store, salt, () => collectLastWinsYielding(ownKnowledgeEntries({ store, salt })));
+  const resolveKnowledge = async (id) => store.getNode(id) ? id : lookupLive(store, own, id);
+  const queuePath = opts.edgeQueuePath ?? causalEdgeQueuePath(workspacePaths(root).configDir);
+  let parked = pruneCausalEdgeQueue(loadCausalEdgeQueue(queuePath), clock());
+  let parkedDirty = false;
+  const parkedKeys = new Set(parked.map((p) => parkedEdgeKey(p.edge)));
   const limit = opts.limit ?? SYNC_PAGE;
   const maxPages = opts.maxPages ?? SYNC_MAX_PAGES;
   let anchors = 0;
   let updated = 0;
   let dropped = 0;
   let landed = 0;
-  let cursor = profile.projectAnchorCursor ?? 0;
+  let edgesLanded = 0;
+  let edgesParked = 0;
+  let edgesReplayed = 0;
+  let persistedCursor = 0;
+  let cursor = 0;
+  let backfillPending = false;
+  let backfillStarted = false;
+  const settleEdges = async (incoming) => {
+    for (const e of incoming) {
+      if (!SYNC_EDGE_TYPES.has(e.type)) continue;
+      const from = await resolveKnowledge(e.from);
+      const to = from ? await resolveKnowledge(e.to) : null;
+      const k = parkedEdgeKey(e);
+      if (from && to) {
+        if (from !== to && landCloudEdge(store, e, from, to)) edgesLanded++;
+        if (parkedKeys.delete(k)) {
+          parked = parked.filter((p) => parkedEdgeKey(p.edge) !== k);
+          parkedDirty = true;
+        }
+      } else if (!parkedKeys.has(k)) {
+        parkedKeys.add(k);
+        parked.push({ edge: e, ts: clock() });
+        parkedDirty = true;
+        edgesParked++;
+      }
+    }
+    if (parked.length === 0) return;
+    const still = [];
+    for (const p of parked) {
+      const from = await resolveKnowledge(p.edge.from);
+      const to = from ? await resolveKnowledge(p.edge.to) : null;
+      if (from && to) {
+        if (from !== to && landCloudEdge(store, p.edge, from, to)) edgesReplayed++;
+        parkedKeys.delete(parkedEdgeKey(p.edge));
+        parkedDirty = true;
+      } else {
+        still.push(p);
+      }
+    }
+    parked = still;
+  };
+  const flushParked = () => {
+    if (!parkedDirty) return;
+    parked = pruneCausalEdgeQueue(parked, clock());
+    saveCausalEdgeQueue(queuePath, parked);
+    parkedDirty = false;
+  };
   try {
     await syncHistoryCorrections({ root, profile, store, cloud, ...opts.correctionMirrors ? { mirrors: opts.correctionMirrors } : {} });
+    persistedCursor = profile.projectAnchorCursor ?? 0;
+    backfillPending = !profile.projectCausalBackfillAt;
+    cursor = backfillPending ? 0 : persistedCursor;
     for (let page = 0; page < maxPages; page++) {
+      if (page > 0) await new Promise((r) => setImmediate(r));
       const res = await cloud.getProjectAnchors(projectId, cursor, limit);
+      if (backfillPending) {
+        backfillPending = false;
+        if (res.causalLeg) {
+          profile.projectCausalBackfillAt = clock();
+          profile.projectAnchorCursor = 0;
+          saveProfile(root, profile);
+          backfillStarted = persistedCursor > 0;
+        } else if (cursor !== persistedCursor) {
+          cursor = persistedCursor;
+          page--;
+          continue;
+        }
+      }
       if (res.anchors.length === 0) break;
       if ((await reverse.get()).size === 0 && (await reverse.refresh()).size === 0) {
         return { synced: false, reason: "no-local-symbols" };
       }
-      const byId = new Map(res.nodes.map((n) => [n.id, n]));
-      const now = Date.now();
+      for (const node2 of res.nodes) {
+        if (store.getNode(node2.id)) continue;
+        const ownTwin = await lookupLive(store, own, node2.id) !== null;
+        if (landCloudNode(store, node2, ownTwin) === "landed") landed++;
+      }
+      const now = clock();
       for (const a of res.anchors) {
         if (a.type !== "ANCHORED_AT") continue;
         const localTo = await lookupLive(store, reverse, a.toSymbolId);
@@ -90150,16 +90887,10 @@ async function syncProjectAnchors(opts) {
           dropped++;
           continue;
         }
-        let from = store.getNode(a.from) ? a.from : await lookupLive(store, own, a.from);
+        const from = await resolveKnowledge(a.from);
         if (!from) {
-          const node2 = byId.get(a.from);
-          if (!node2) {
-            dropped++;
-            continue;
-          }
-          store.mergeNode(node2);
-          landed++;
-          from = node2.id;
+          dropped++;
+          continue;
         }
         const existing = existingAnchor(store, from, localTo);
         const id = existing?.id ?? edgeId(from, "ANCHORED_AT", localTo);
@@ -90191,6 +90922,8 @@ async function syncProjectAnchors(opts) {
         if (existing) updated++;
         else anchors++;
       }
+      await settleEdges(res.edges ?? []);
+      flushParked();
       const next = typeof res.cursor === "number" && res.cursor > cursor ? res.cursor : cursor;
       if (next !== cursor) {
         cursor = next;
@@ -90199,8 +90932,23 @@ async function syncProjectAnchors(opts) {
       }
       if (res.anchors.length < limit) break;
     }
-    return { synced: true, anchors, updated, dropped, landed, cursor };
+    await settleEdges([]);
+    flushParked();
+    return {
+      synced: true,
+      anchors,
+      updated,
+      dropped,
+      landed,
+      cursor,
+      edgesLanded,
+      edgesParked,
+      edgesReplayed,
+      edgesPending: parked.length,
+      backfillStarted
+    };
   } catch (err2) {
+    flushParked();
     return { synced: false, reason: "error", detail: err2 instanceof Error ? err2.message : String(err2) };
   }
 }
@@ -90218,24 +90966,16 @@ async function hydrateProject(opts) {
     let landedNodes = 0;
     let ownNodes = 0;
     for (const n of res.nodes) {
-      if (store.getNode(n.id)) continue;
-      if (own.has(n.id)) {
-        ownNodes++;
-        continue;
-      }
-      store.mergeNode(n);
-      landedNodes++;
+      const landing = landCloudNode(store, n, own.has(n.id));
+      if (landing === "own") ownNodes++;
+      else if (landing === "landed") landedNodes++;
     }
     let landedEdges = 0;
     for (const e of res.edges) {
       const from = localId(e.from);
       const to = localId(e.to);
       if (!from || !to) continue;
-      if (store.outEdges(from, [e.type]).some((x) => x.to === to)) continue;
-      const id = from === e.from && to === e.to ? e.id : edgeId(from, e.type, to);
-      if (store.getEdge(id)) continue;
-      store.mergeEdge({ ...e, id, from, to });
-      landedEdges++;
+      if (landCloudEdge(store, e, from, to)) landedEdges++;
     }
     profile.projectHydratedAt = Date.now();
     saveProfile(root, profile);
@@ -90499,8 +91239,8 @@ async function syncHistoryRevisionPage(opts) {
 init_src7();
 init_src();
 import { execFile as execFile6 } from "node:child_process";
-import { readFileSync as readFileSync35 } from "node:fs";
-import { join as join39 } from "node:path";
+import { readFileSync as readFileSync36 } from "node:fs";
+import { join as join40 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 
 // src/history-walk.ts
@@ -91052,7 +91792,7 @@ async function defaultGit(root, args2) {
 function readIgnoreLines(root, profile) {
   let lines = [];
   try {
-    lines = readFileSync35(join39(root, ".errataignore"), "utf8").split("\n");
+    lines = readFileSync36(join40(root, ".errataignore"), "utf8").split("\n");
   } catch {
   }
   return [...lines, ...profile.ignoreExtra ?? []].map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
@@ -91628,8 +92368,8 @@ async function startHistoryStage(root, input, client, walk11 = {}) {
 init_cloud_auth();
 import { createHash as createHash19 } from "node:crypto";
 import { execFileSync as execFileSync6 } from "node:child_process";
-import { existsSync as existsSync32, writeFileSync as writeFileSync25 } from "node:fs";
-import { join as join40 } from "node:path";
+import { existsSync as existsSync32, writeFileSync as writeFileSync26 } from "node:fs";
+import { join as join41 } from "node:path";
 
 // src/device-poll.ts
 var THROTTLED_POLL_MIN_WAIT_MS = 11e3;
@@ -92088,9 +92828,9 @@ function applyLinkDecision(root, profile, config2, decision, now = Date.now) {
   delete nextProfile.projectLinkHold;
   let wroteIgnore = false;
   if (decision.writeIgnoreStarter !== false) {
-    const target = join40(root, ".errataignore");
+    const target = join41(root, ".errataignore");
     if (!existsSync32(target)) {
-      writeFileSync25(target, IGNORE_STARTER, "utf8");
+      writeFileSync26(target, IGNORE_STARTER, "utf8");
       wroteIgnore = true;
     }
   }
@@ -92104,12 +92844,12 @@ init_registry();
 // src/adopt.ts
 init_git_remote();
 import { existsSync as existsSync33 } from "node:fs";
-import { dirname as dirname13, join as join41 } from "node:path";
+import { dirname as dirname14, join as join42 } from "node:path";
 function findGitRoot(absPath) {
   let dir = absPath;
   for (let depth = 0; depth < 64; depth++) {
-    if (existsSync33(join41(dir, ".git"))) return dir;
-    const parent = dirname13(dir);
+    if (existsSync33(join42(dir, ".git"))) return dir;
+    const parent = dirname14(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -92826,7 +93566,7 @@ async function startMultiDaemon(opts = {}) {
     records.push(rec);
     void ambientLinkAll();
     try {
-      writeFileSync26(
+      writeFileSync27(
         rec.engine.paths.daemonLock,
         daemonLockPayload({
           pid: process.pid,
@@ -93205,7 +93945,7 @@ async function startMultiDaemon(opts = {}) {
   baseUrl = `http://127.0.0.1:${port}`;
   try {
     ensureDir(globalDir());
-    writeFileSync26(
+    writeFileSync27(
       lockPath,
       daemonLockPayload({ pid: process.pid, webUiUrl: baseUrl, processStartedAt: PROCESS_STARTED_AT, entry: SELF_ENTRY, version: DAEMON_VERSION }),
       "utf8"
@@ -93214,7 +93954,7 @@ async function startMultiDaemon(opts = {}) {
   }
   for (const r of records) {
     try {
-      writeFileSync26(
+      writeFileSync27(
         r.engine.paths.daemonLock,
         daemonLockPayload({
           pid: process.pid,
@@ -93256,6 +93996,7 @@ async function startMultiDaemon(opts = {}) {
   const lastAnchorPull = /* @__PURE__ */ new Map();
   const pullProjectAnchors = async (r, client, salt) => {
     const donePass = markPass(`anchor-pull:${r.engine.profile.name}`);
+    const pullStartedAt = Date.now();
     const beforeCorrections = r.engine.profile.projectHistoryCorrectionCursor ?? 0;
     const sync = await syncProjectAnchors({
       root: r.root,
@@ -93277,10 +94018,22 @@ async function startMultiDaemon(opts = {}) {
       console.warn(`[errata] history revision reconciliation failed for ${r.engine.profile.name}: ${err2 instanceof Error ? err2.message : String(err2)}`);
     }
     if (sync.synced) {
-      if (sync.anchors + sync.updated > 0) {
+      appendPassLedger(r.engine.paths.configDir, "anchor-pull", Date.now() - pullStartedAt, {
+        anchorsLanded: sync.anchors,
+        anchorsUpdated: sync.updated,
+        nodesLanded: sync.landed,
+        edgesLanded: sync.edgesLanded + sync.edgesReplayed,
+        edgesParked: sync.edgesParked,
+        edgesReplayed: sync.edgesReplayed,
+        edgesPending: sync.edgesPending
+      });
+      if (sync.backfillStarted) {
+        console.log(`[errata] causal re-walk started for ${r.engine.profile.name} \u2014 anchor cursor reset to 0 once`);
+      }
+      if (sync.anchors + sync.updated + sync.landed + sync.edgesLanded + sync.edgesReplayed > 0) {
         r.engine.markContextDirty();
         console.log(
-          `[errata] anchors pulled for ${r.engine.profile.name} \u2014 ${sync.anchors} new, ${sync.updated} re-versioned, ${sync.dropped} unresolved (${sync.landed} priors landed, cursor ${sync.cursor})`
+          `[errata] anchors pulled for ${r.engine.profile.name} \u2014 ${sync.anchors} new, ${sync.updated} re-versioned, ${sync.dropped} unresolved (${sync.landed} priors landed, ${sync.edgesLanded + sync.edgesReplayed} causal edges landed, ${sync.edgesPending} parked, cursor ${sync.cursor})`
         );
       }
     } else if (sync.reason === "error") {
@@ -94696,7 +95449,7 @@ import { spawnSync as spawnSync2 } from "node:child_process";
 
 // src/codex-runtime.ts
 import { readdirSync as readdirSync13, statSync as statSync10 } from "node:fs";
-import { join as join42 } from "node:path";
+import { join as join43 } from "node:path";
 function resolveCodexExecutable(options = {}) {
   const platform = options.platform ?? process.platform;
   const env2 = options.env ?? process.env;
@@ -94711,13 +95464,13 @@ function resolveCodexExecutable(options = {}) {
   };
   for (const dir of (env2["PATH"] ?? env2["Path"] ?? "").split(";")) {
     if (!dir.trim()) continue;
-    const path3 = join42(dir.trim().replace(/^"|"$/g, ""), "codex.exe");
+    const path3 = join43(dir.trim().replace(/^"|"$/g, ""), "codex.exe");
     if (fileTime(path3) !== null) return path3;
   }
   if (!env2["LOCALAPPDATA"]) return "codex";
-  const root = join42(env2["LOCALAPPDATA"], "OpenAI", "Codex", "bin");
+  const root = join43(env2["LOCALAPPDATA"], "OpenAI", "Codex", "bin");
   try {
-    const candidates = readdirSync13(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join42(root, entry.name, "codex.exe")).map((path3) => ({ path: path3, mtime: fileTime(path3) })).filter((candidate) => candidate.mtime !== null).sort((a, b) => b.mtime - a.mtime || a.path.localeCompare(b.path));
+    const candidates = readdirSync13(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join43(root, entry.name, "codex.exe")).map((path3) => ({ path: path3, mtime: fileTime(path3) })).filter((candidate) => candidate.mtime !== null).sort((a, b) => b.mtime - a.mtime || a.path.localeCompare(b.path));
     return candidates[0]?.path ?? "codex";
   } catch {
     return "codex";
@@ -94856,14 +95609,14 @@ async function diagnoseInstallation(cfg, dependencies) {
 
 // src/codex-doctor.ts
 import { spawn as spawn4 } from "node:child_process";
-import { readFileSync as readFileSync37, statSync as statSync11 } from "node:fs";
-import { join as join44 } from "node:path";
+import { readFileSync as readFileSync38, statSync as statSync11 } from "node:fs";
+import { join as join45 } from "node:path";
 import { createInterface } from "node:readline";
 
 // src/codex-hooks.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync9, readFileSync as readFileSync36, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync27 } from "node:fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync9, readFileSync as readFileSync37, renameSync as renameSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync28 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { join as join43 } from "node:path";
+import { join as join44 } from "node:path";
 
 // src/hook-commands.ts
 function hookCurlCommand(port, path3 = "/api/hook") {
@@ -95067,34 +95820,34 @@ function buildCodexRelaySource(workspaceRoot) {
 init_checkout_root();
 var CODEX_HOOK_REVIEW_HELP = "Codex desktop: Settings > Hooks, select this project, expand each event and Trust the Errata hook. CLI users can use /hooks.";
 function writeRelay(file2, source) {
-  if (existsSync35(file2) && readFileSync36(file2, "utf8") === source) return;
+  if (existsSync35(file2) && readFileSync37(file2, "utf8") === source) return;
   const temp = `${file2}.${process.pid}.tmp`;
   try {
-    writeFileSync27(temp, source, { encoding: "utf8", mode: 384 });
-    renameSync5(temp, file2);
+    writeFileSync28(temp, source, { encoding: "utf8", mode: 384 });
+    renameSync6(temp, file2);
   } finally {
     if (existsSync35(temp)) unlinkSync5(temp);
   }
 }
 function refreshCodexRelay(root) {
-  const config2 = join43(root, ".codex", "config.toml");
+  const config2 = join44(root, ".codex", "config.toml");
   if (!existsSync35(config2)) return "absent";
-  const existing = readFileSync36(config2, "utf8");
+  const existing = readFileSync37(config2, "utf8");
   if (!existing.includes(CODEX_HOOKS_BEGIN) && !existing.includes(CODEX_HOOKS_END)) return "absent";
   replaceCodexHooks(existing, "");
-  const relay = join43(root, ".codex", "hooks", "errata-relay.mjs");
-  const prior = existsSync35(relay) ? readFileSync36(relay, "utf8") : "";
+  const relay = join44(root, ".codex", "hooks", "errata-relay.mjs");
+  const prior = existsSync35(relay) ? readFileSync37(relay, "utf8") : "";
   if (prior && !prior.startsWith("// errata-managed: regenerated by errata install-hooks codex")) {
     throw new Error("Codex relay is not Errata-managed; preserved it. Run errata install-hooks codex to explicitly replace it.");
   }
   const source = buildCodexRelaySource(checkoutRootOf(root));
   if (prior === source) return "current";
-  mkdirSync9(join43(root, ".codex", "hooks"), { recursive: true });
+  mkdirSync9(join44(root, ".codex", "hooks"), { recursive: true });
   writeRelay(relay, source);
   return "updated";
 }
-function hasCodexConfig(root, codexHome = process.env["CODEX_HOME"] || join43(homedir7(), ".codex")) {
-  return existsSync35(join43(root, ".codex")) || existsSync35(codexHome);
+function hasCodexConfig(root, codexHome = process.env["CODEX_HOME"] || join44(homedir7(), ".codex")) {
+  return existsSync35(join44(root, ".codex")) || existsSync35(codexHome);
 }
 function replaceCodexHooks(existing, block) {
   const begin = existing.indexOf(CODEX_HOOKS_BEGIN);
@@ -95110,14 +95863,14 @@ function replaceCodexHooks(existing, block) {
   return existing.trimEnd() + (existing.trim() ? "\n\n" : "") + block;
 }
 function writeCodexHooks(root, port, nodePath = process.execPath) {
-  const dir = join43(root, ".codex");
-  const file2 = join43(dir, "config.toml");
-  const relay = join43(dir, "hooks", "errata-relay.mjs");
+  const dir = join44(root, ".codex");
+  const file2 = join44(dir, "config.toml");
+  const relay = join44(dir, "hooks", "errata-relay.mjs");
   const block = buildCodexHooksToml(port, { nodePath, relayPath: relay });
-  const final = replaceCodexHooks(existsSync35(file2) ? readFileSync36(file2, "utf8") : "", block);
-  mkdirSync9(join43(dir, "hooks"), { recursive: true });
+  const final = replaceCodexHooks(existsSync35(file2) ? readFileSync37(file2, "utf8") : "", block);
+  mkdirSync9(join44(dir, "hooks"), { recursive: true });
   writeRelay(relay, buildCodexRelaySource(checkoutRootOf(root)));
-  if (!existsSync35(file2) || readFileSync36(file2, "utf8") !== final) writeFileSync27(file2, final, "utf8");
+  if (!existsSync35(file2) || readFileSync37(file2, "utf8") !== final) writeFileSync28(file2, final, "utf8");
   return file2;
 }
 
@@ -95126,7 +95879,7 @@ init_checkout_root();
 function inspectCodexRelay(cwd) {
   const root = nearestGitRoot(cwd) ?? cwd;
   try {
-    const source = readFileSync37(join44(root, ".codex", "hooks", "errata-relay.mjs"), "utf8");
+    const source = readFileSync38(join45(root, ".codex", "hooks", "errata-relay.mjs"), "utf8");
     if (source === buildCodexRelaySource(checkoutRootOf(root))) {
       return { id: "codex_relay", status: "pass", detail: "Installed Codex relay matches this Errata version" };
     }
@@ -95137,8 +95890,8 @@ function inspectCodexRelay(cwd) {
 function inspectCodexContext(cwd) {
   const root = checkoutRootOf(nearestGitRoot(cwd) ?? cwd);
   try {
-    const file2 = join44(root, ".errata", "context.md");
-    if (statSync11(file2).size <= 128 * 1024 && readFileSync37(file2, "utf8").trim()) {
+    const file2 = join45(root, ".errata", "context.md");
+    if (statSync11(file2).size <= 128 * 1024 && readFileSync38(file2, "utf8").trim()) {
       return { id: "codex_context", status: "pass", detail: "Saved workspace context is readable by the relay; this does not prove live daemon freshness" };
     }
   } catch {
@@ -95316,9 +96069,9 @@ function consolidationGapMs(lastPassMs, policy) {
 
 // src/codex-context-plugin.ts
 import { createHash as createHash20 } from "node:crypto";
-import { cpSync as cpSync2, existsSync as existsSync36, mkdirSync as mkdirSync10, readFileSync as readFileSync38, renameSync as renameSync6, writeFileSync as writeFileSync28 } from "node:fs";
+import { cpSync as cpSync2, existsSync as existsSync36, mkdirSync as mkdirSync10, readFileSync as readFileSync39, renameSync as renameSync7, writeFileSync as writeFileSync29 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { join as join45 } from "node:path";
+import { join as join46 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/error.js
@@ -96016,23 +96769,23 @@ var NAME = "errata-context";
 var PREFIX2 = `./.errata/plugins/${NAME}/`;
 var object2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 function readText(file2) {
-  return existsSync36(file2) ? readFileSync38(file2, "utf8") : "";
+  return existsSync36(file2) ? readFileSync39(file2, "utf8") : "";
 }
 function writeChanged(file2, content) {
   if (readText(file2) === content) return;
   const temp = `${file2}.${process.pid}.tmp`;
-  writeFileSync28(temp, content, "utf8");
-  renameSync6(temp, file2);
+  writeFileSync29(temp, content, "utf8");
+  renameSync7(temp, file2);
 }
 function bundledContextPlugin() {
   const packaged = fileURLToPath2(new URL("./resources/context-plugin/", import.meta.url));
-  if (existsSync36(join45(packaged, ".codex-plugin/plugin.json"))) return packaged;
+  if (existsSync36(join46(packaged, ".codex-plugin/plugin.json"))) return packaged;
   return fileURLToPath2(new URL("../dist/resources/context-plugin/", import.meta.url));
 }
 function refreshCodexContextPlugin(root) {
-  const file2 = join45(root, ".agents", "plugins", "marketplace.json");
+  const file2 = join46(root, ".agents", "plugins", "marketplace.json");
   if (!existsSync36(file2)) return false;
-  const marketplace = JSON.parse(readFileSync38(file2, "utf8"));
+  const marketplace = JSON.parse(readFileSync39(file2, "utf8"));
   const entries = Array.isArray(marketplace.plugins) ? marketplace.plugins : [];
   const entry = entries.map(object2).find((value) => value.name === NAME && String(object2(value.source).path).startsWith(PREFIX2));
   if (!entry) return false;
@@ -96043,24 +96796,24 @@ function refreshCodexContextPlugin(root) {
 function installCodexContextPlugin(root, options = {}) {
   const bundle = options.bundle ?? bundledContextPlugin();
   const manifest = JSON.parse(
-    readFileSync38(join45(bundle, ".codex-plugin/plugin.json"), "utf8")
+    readFileSync39(join46(bundle, ".codex-plugin/plugin.json"), "utf8")
   );
   if (manifest.name !== NAME || typeof manifest.version !== "string" || !/^[\w.-]+$/.test(manifest.version)) {
     throw new Error("Invalid bundled Errata Context manifest.");
   }
-  const checksums = readFileSync38(join45(bundle, "SHA256SUMS"), "utf8");
+  const checksums = readFileSync39(join46(bundle, "SHA256SUMS"), "utf8");
   for (const line of checksums.trim().split("\n")) {
     const match2 = /^([a-f0-9]{64})  ([\w./-]+)$/.exec(line);
     if (!match2 || match2[2].startsWith("/") || match2[2].split("/").includes("..")) {
       throw new Error("Invalid bundled Errata Context checksum manifest.");
     }
-    const actual = createHash20("sha256").update(readFileSync38(join45(bundle, match2[2]))).digest("hex");
+    const actual = createHash20("sha256").update(readFileSync39(join46(bundle, match2[2]))).digest("hex");
     if (actual !== match2[1])
       throw new Error(`Bundled Errata Context checksum mismatch: ${match2[2]}`);
   }
   const release = `${manifest.version}-${createHash20("sha256").update(checksums).digest("hex").slice(0, 12)}`;
-  const plugin = join45(root, ".errata", "plugins", NAME, release);
-  const marketplaceFile = join45(root, ".agents", "plugins", "marketplace.json");
+  const plugin = join46(root, ".errata", "plugins", NAME, release);
+  const marketplaceFile = join46(root, ".agents", "plugins", "marketplace.json");
   const priorMarketplace = readText(marketplaceFile);
   const marketplace = priorMarketplace ? JSON.parse(priorMarketplace) : {
     name: "errata-local",
@@ -96081,12 +96834,12 @@ function installCodexContextPlugin(root, options = {}) {
     );
   }
   const key = `${NAME}@${marketplace.name}`;
-  const configFile = join45(root, ".codex", "config.toml");
+  const configFile = join46(root, ".codex", "config.toml");
   const config2 = readText(configFile);
   const parsed = parse4(config2);
   const plugins = object2(parsed.plugins);
-  const codexHome = options.codexHome ?? process.env["CODEX_HOME"] ?? join45(homedir8(), ".codex");
-  const globalPlugins = object2(parse4(readText(join45(codexHome, "config.toml"))).plugins);
+  const codexHome = options.codexHome ?? process.env["CODEX_HOME"] ?? join46(homedir8(), ".codex");
+  const globalPlugins = object2(parse4(readText(join46(codexHome, "config.toml"))).plugins);
   const disabledGlobally = Object.entries(globalPlugins).some(
     ([name2, value]) => (name2 === NAME || name2.startsWith(`${NAME}@`)) && object2(value).enabled === false
   );
@@ -96110,13 +96863,13 @@ enabled = ${enabled}
   mkdirSync10(plugin, { recursive: true });
   cpSync2(bundle, plugin, { recursive: true });
   writeChanged(
-    join45(plugin, ".mcp.json"),
+    join46(plugin, ".mcp.json"),
     JSON.stringify(
       {
         mcpServers: {
           errata_context: {
             command: options.nodePath ?? process.execPath,
-            args: [join45(plugin, "dist", "mcp-server.mjs")],
+            args: [join46(plugin, "dist", "mcp-server.mjs")],
             env: { ERRATA_WORKSPACE: root, ERRATA_CONTEXT_VERSION: manifest.version }
           }
         }
@@ -96125,8 +96878,8 @@ enabled = ${enabled}
       2
     ) + "\n"
   );
-  mkdirSync10(join45(root, ".agents", "plugins"), { recursive: true });
-  mkdirSync10(join45(root, ".codex"), { recursive: true });
+  mkdirSync10(join46(root, ".agents", "plugins"), { recursive: true });
+  mkdirSync10(join46(root, ".codex"), { recursive: true });
   writeChanged(marketplaceFile, JSON.stringify(marketplace, null, 2) + "\n");
   writeChanged(configFile, nextConfig);
   return { plugin, enabled, marketplace: marketplaceFile };
@@ -96134,15 +96887,15 @@ enabled = ${enabled}
 
 // src/codex-hook-refresh.ts
 init_checkout_root();
-import { existsSync as existsSync37, readdirSync as readdirSync14, readFileSync as readFileSync39 } from "node:fs";
-import { dirname as dirname14, join as join46, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync37, readdirSync as readdirSync14, readFileSync as readFileSync40 } from "node:fs";
+import { dirname as dirname15, join as join47, resolve as resolve8 } from "node:path";
 init_registry();
 function codexHookRoots(roots) {
   const found = new Set(roots.map((root) => resolve8(root)));
   for (const root of [...found]) {
     const main2 = mainCheckoutOfWorktree(root) ?? root;
     found.add(main2);
-    const dir = join46(main2, ".git", "worktrees");
+    const dir = join47(main2, ".git", "worktrees");
     if (!existsSync37(dir)) continue;
     let names;
     try {
@@ -96152,7 +96905,7 @@ function codexHookRoots(roots) {
     }
     for (const name2 of names) {
       try {
-        const checkout = dirname14(readFileSync39(join46(dir, name2, "gitdir"), "utf8").trim());
+        const checkout = dirname15(readFileSync40(join47(dir, name2, "gitdir"), "utf8").trim());
         if (mainCheckoutOfWorktree(checkout) === main2) found.add(checkout);
       } catch {
       }
@@ -96174,9 +96927,9 @@ function refreshInstalledCodexRelays(roots = listWorkspaceEntries().map((entry)
 }
 
 // src/claude-statusline.ts
-import { existsSync as existsSync38, mkdirSync as mkdirSync11, readFileSync as readFileSync40, writeFileSync as writeFileSync29 } from "node:fs";
+import { existsSync as existsSync38, mkdirSync as mkdirSync11, readFileSync as readFileSync41, writeFileSync as writeFileSync30 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
-import { dirname as dirname15, join as join47 } from "node:path";
+import { dirname as dirname16, join as join48 } from "node:path";
 var STATUSLINE_RELAY_SOURCE = String.raw`// errata-managed: regenerated by errata init / install-hooks claude
 import { readFileSync } from 'node:fs';
 
@@ -96224,8 +96977,8 @@ function isSameInstall(value, relay) {
   return command.includes(relay.replace(/\\/g, "/").toLowerCase());
 }
 function userClaudeSettingsPath() {
-  const base = process.env["CLAUDE_CONFIG_DIR"] ?? join47(homedir9(), ".claude");
-  return join47(base, "settings.json");
+  const base = process.env["CLAUDE_CONFIG_DIR"] ?? join48(homedir9(), ".claude");
+  return join48(base, "settings.json");
 }
 function ensureUserStatusLine(opts) {
   const env2 = opts.env ?? process.env;
@@ -96235,21 +96988,21 @@ function ensureUserStatusLine(opts) {
   let settings = {};
   if (existsSync38(settingsPath)) {
     try {
-      const parsed = JSON.parse(readFileSync40(settingsPath, "utf8"));
+      const parsed = JSON.parse(readFileSync41(settingsPath, "utf8"));
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return "unreadable";
       settings = parsed;
     } catch {
       return "unreadable";
     }
   }
-  const relay = join47(opts.relayDir, STATUSLINE_RELAY_FILE);
+  const relay = join48(opts.relayDir, STATUSLINE_RELAY_FILE);
   const keep = (value) => value !== void 0 && (!isErrataStatusLine(value) || !isSameInstall(value, relay));
   const ownMain = keep(settings["statusLine"]);
   const ownRows = keep(settings["subagentStatusLine"]);
   if (ownMain && ownRows) return "kept-own";
   mkdirSync11(opts.relayDir, { recursive: true });
-  if (!existsSync38(relay) || readFileSync40(relay, "utf8") !== STATUSLINE_RELAY_SOURCE) {
-    writeFileSync29(relay, STATUSLINE_RELAY_SOURCE, "utf8");
+  if (!existsSync38(relay) || readFileSync41(relay, "utf8") !== STATUSLINE_RELAY_SOURCE) {
+    writeFileSync30(relay, STATUSLINE_RELAY_SOURCE, "utf8");
   }
   const nodePath = opts.nodePath ?? process.execPath;
   const next = {
@@ -96260,8 +97013,8 @@ function ensureUserStatusLine(opts) {
     return ownMain ? "kept-own" : "unchanged";
   }
   Object.assign(settings, next);
-  mkdirSync11(dirname15(settingsPath), { recursive: true });
-  writeFileSync29(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  mkdirSync11(dirname16(settingsPath), { recursive: true });
+  writeFileSync30(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
   return "installed";
 }
 function describeStatusLineOutcome(outcome) {
@@ -96281,8 +97034,8 @@ function describeStatusLineOutcome(outcome) {
 
 // src/claude-mods.ts
 import { createHash as createHash21 } from "node:crypto";
-import { cpSync as cpSync3, existsSync as existsSync39, mkdirSync as mkdirSync12, readFileSync as readFileSync41, readdirSync as readdirSync15, rmSync as rmSync4, statSync as statSync12, writeFileSync as writeFileSync30 } from "node:fs";
-import { delimiter as delimiter2, dirname as dirname16, join as join48, relative as relative8, resolve as resolve9, sep as sep5 } from "node:path";
+import { cpSync as cpSync3, existsSync as existsSync39, mkdirSync as mkdirSync12, readFileSync as readFileSync42, readdirSync as readdirSync15, rmSync as rmSync4, statSync as statSync12, writeFileSync as writeFileSync31 } from "node:fs";
+import { delimiter as delimiter2, dirname as dirname17, join as join49, relative as relative8, resolve as resolve9, sep as sep5 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var CLAUDE_PLUGIN_DIRS_ENV = "CLAUDE_CODE_PLUGIN_DIRS";
 var HASH_FILE = ".errata-mod-hash";
@@ -96297,7 +97050,7 @@ function isEngineOwned(relPath) {
 function listFiles(root, dir = root) {
   const out2 = [];
   for (const name2 of readdirSync15(dir)) {
-    const abs = join48(dir, name2);
+    const abs = join49(dir, name2);
     if (isEngineOwned(relative8(root, abs))) continue;
     if (statSync12(abs).isDirectory()) out2.push(...listFiles(root, abs));
     else out2.push(abs);
@@ -96309,14 +97062,14 @@ function modHash(dir) {
   for (const abs of listFiles(dir).sort()) {
     h.update(relative8(dir, abs).split(sep5).join("/"));
     h.update("\0");
-    h.update(readFileSync41(abs));
+    h.update(readFileSync42(abs));
     h.update("\0");
   }
   return h.digest("hex");
 }
 function bundledMods(bundleDir) {
   if (!existsSync39(bundleDir)) return [];
-  return readdirSync15(bundleDir).filter((name2) => existsSync39(join48(bundleDir, name2, ".claude-plugin", "plugin.json")));
+  return readdirSync15(bundleDir).filter((name2) => existsSync39(join49(bundleDir, name2, ".claude-plugin", "plugin.json")));
 }
 function sameDir(a, b) {
   const norm = (p) => resolve9(p).replace(/[\\/]+$/, "").toLowerCase();
@@ -96333,7 +97086,7 @@ function off(env2) {
 function readSettings(path3) {
   if (!existsSync39(path3)) return {};
   try {
-    const parsed = JSON.parse(readFileSync41(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync42(path3, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
     return parsed;
   } catch {
@@ -96357,13 +97110,13 @@ function currentDirs(settings) {
   return raw2.split(delimiter2).map((s) => s.trim()).filter(Boolean);
 }
 function writeSettings(path3, settings) {
-  mkdirSync12(dirname16(path3), { recursive: true });
-  writeFileSync30(path3, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  mkdirSync12(dirname17(path3), { recursive: true });
+  writeFileSync31(path3, JSON.stringify(settings, null, 2) + "\n", "utf8");
 }
 function ensureClaudeMods(opts) {
   const env2 = opts.env ?? process.env;
   const settingsPath = opts.userSettingsPath ?? userClaudeSettingsPath();
-  const modsRoot = join48(opts.installRoot, "claude-mods");
+  const modsRoot = join49(opts.installRoot, "claude-mods");
   if (off(env2)) {
     const settings2 = readSettings(settingsPath);
     if (!settings2) return { kind: "unreadable" };
@@ -96380,14 +97133,14 @@ function ensureClaudeMods(opts) {
   let changed = false;
   const installed = [];
   for (const name2 of names) {
-    const src = join48(bundleDir, name2);
-    const dest = join48(modsRoot, name2);
+    const src = join49(bundleDir, name2);
+    const dest = join49(modsRoot, name2);
     const hash2 = modHash(src);
-    const hashFile = join48(dest, HASH_FILE);
-    if (!existsSync39(hashFile) || readFileSync41(hashFile, "utf8") !== hash2) {
+    const hashFile = join49(dest, HASH_FILE);
+    if (!existsSync39(hashFile) || readFileSync42(hashFile, "utf8") !== hash2) {
       rmSync4(dest, { recursive: true, force: true });
       cpSync3(src, dest, { recursive: true, filter: (p) => !isEngineOwned(relative8(src, p)) });
-      writeFileSync30(hashFile, hash2, "utf8");
+      writeFileSync31(hashFile, hash2, "utf8");
       changed = true;
     }
     installed.push(dest);
@@ -96808,9 +97561,9 @@ function resolveHookPort(explicit) {
       }
     }
   }
-  const settingsPath = join49(ROOT, ".claude", "settings.json");
+  const settingsPath = join50(ROOT, ".claude", "settings.json");
   try {
-    if (existsSync40(settingsPath)) return installedHookPort(readFileSync42(settingsPath, "utf8")) ?? 7891;
+    if (existsSync40(settingsPath)) return installedHookPort(readFileSync43(settingsPath, "utf8")) ?? 7891;
   } catch {
   }
   return 7891;
@@ -96836,13 +97589,13 @@ async function cmdInit() {
     console.log("");
     console.log("installing harness hooks...");
     const { existsSync: existsSync41 } = await import("node:fs");
-    const { join: join50 } = await import("node:path");
+    const { join: join51 } = await import("node:path");
     try {
       await installClaudeHooks(port);
     } catch (err2) {
       console.warn(`  \u26A0\uFE0F  Claude hook install failed: ${err2 instanceof Error ? err2.message : err2}`);
     }
-    if (existsSync41(join50(ROOT, ".cursor"))) {
+    if (existsSync41(join51(ROOT, ".cursor"))) {
       try {
         await installCursorMcpConfig();
       } catch (err2) {
@@ -98064,7 +98817,7 @@ async function cmdReview() {
     console.log("(review queue empty)");
     return;
   }
-  const queue = JSON.parse(readFileSync42(paths.reviewQueue, "utf8"));
+  const queue = JSON.parse(readFileSync43(paths.reviewQueue, "utf8"));
   if (queue.length === 0) {
     console.log("(review queue empty)");
     return;
@@ -98803,7 +99556,7 @@ async function gatherReportData(generatedAt) {
   };
 }
 async function cmdReport(args2) {
-  const { mkdirSync: mkdirSync13, writeFileSync: writeFileSync31 } = await import("node:fs");
+  const { mkdirSync: mkdirSync13, writeFileSync: writeFileSync32 } = await import("node:fs");
   const { renderReport: renderReport2 } = await Promise.resolve().then(() => (init_report_render(), report_render_exports));
   const includeFutureVerbs = args2.includes("--future-verbs");
   const now = /* @__PURE__ */ new Date();
@@ -98816,8 +99569,8 @@ async function cmdReport(args2) {
   const outDir = workspacePaths(ROOT).configDir;
   mkdirSync13(outDir, { recursive: true });
   const files = renderReport2(data, { includeFutureVerbs });
-  for (const f of files) writeFileSync31(join49(outDir, f.name), f.html, "utf8");
-  const indexPath = join49(outDir, "report.html");
+  for (const f of files) writeFileSync32(join50(outDir, f.name), f.html, "utf8");
+  const indexPath = join50(outDir, "report.html");
   console.log(`report \u2192 ${indexPath}`);
   console.log(
     `  ${data.repos.length} repo(s) \xB7 ${files.length} file(s) \xB7 ${data.rollup.nodes.toLocaleString("en-US")} nodes`
@@ -98873,7 +99626,7 @@ function spawnDaemonDetached(options = {}) {
   try {
     const logPath = daemonLogPath();
     try {
-      if (statSync13(logPath).size > 5 * 1024 * 1024) renameSync7(logPath, `${logPath}.1`);
+      if (statSync13(logPath).size > 5 * 1024 * 1024) renameSync8(logPath, `${logPath}.1`);
     } catch {
     }
     out2 = openSync3(logPath, "a");
@@ -98942,24 +99695,24 @@ async function cmdInstallHooks(args2) {
   }
 }
 async function installOpencodePlugin(port) {
-  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync43, writeFileSync: writeFileSync31 } = await import("node:fs");
-  const { join: join50 } = await import("node:path");
-  const dir = join50(ROOT, ".opencode", "plugin");
+  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync44, writeFileSync: writeFileSync32 } = await import("node:fs");
+  const { join: join51 } = await import("node:path");
+  const dir = join51(ROOT, ".opencode", "plugin");
   if (!existsSync41(dir)) mkdirSync13(dir, { recursive: true });
-  const file2 = join50(dir, "inerrata.js");
+  const file2 = join51(dir, "inerrata.js");
   if (existsSync41(file2)) {
-    const head2 = readFileSync43(file2, "utf8").split("\n")[0] ?? "";
+    const head2 = readFileSync44(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);
     }
   }
-  writeFileSync31(file2, buildOpencodePluginSource(port, { version: DAEMON_VERSION }), "utf8");
-  const cfgFile = join50(ROOT, "opencode.json");
+  writeFileSync32(file2, buildOpencodePluginSource(port, { version: DAEMON_VERSION }), "utf8");
+  const cfgFile = join51(ROOT, "opencode.json");
   let cfg = { $schema: "https://opencode.ai/config.json" };
   if (existsSync41(cfgFile)) {
     try {
-      cfg = JSON.parse(readFileSync43(cfgFile, "utf8"));
+      cfg = JSON.parse(readFileSync44(cfgFile, "utf8"));
     } catch {
       console.error(`refusing to touch invalid JSON at ${cfgFile} \u2014 fix it and re-run`);
       process.exit(2);
@@ -98970,7 +99723,7 @@ async function installOpencodePlugin(port) {
   if (!hadErrata) {
     const inv = errataMcpInvocation();
     cfg.mcp["errata"] = { type: "local", command: [inv.command, ...inv.args] };
-    writeFileSync31(cfgFile, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+    writeFileSync32(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`);
@@ -99005,15 +99758,15 @@ function installClaudeMods() {
   }
 }
 async function installClaudeHooks(port) {
-  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync43, writeFileSync: writeFileSync31 } = await import("node:fs");
-  const { join: join50 } = await import("node:path");
-  const dir = join50(ROOT, ".claude");
+  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync44, writeFileSync: writeFileSync32 } = await import("node:fs");
+  const { join: join51 } = await import("node:path");
+  const dir = join51(ROOT, ".claude");
   if (!existsSync41(dir)) mkdirSync13(dir, { recursive: true });
-  const file2 = join50(dir, "settings.json");
+  const file2 = join51(dir, "settings.json");
   let settings = {};
   if (existsSync41(file2)) {
     try {
-      settings = JSON.parse(readFileSync43(file2, "utf8"));
+      settings = JSON.parse(readFileSync44(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -99062,12 +99815,12 @@ async function installClaudeHooks(port) {
     list.push({ hooks: [{ type: "command", command: injectCmd }] });
   }
   removeProjectStatusLine(settings);
-  writeFileSync31(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  writeFileSync32(file2, JSON.stringify(settings, null, 2) + "\n", "utf8");
   console.log(`installed Claude Code hooks \u2192 ${file2}`);
   console.log(`  ${ensureStatusLine(port)}`);
   console.log(`  ${installClaudeMods().line}`);
   await installClaudeMcpConfig();
-  const claudeMd = join50(ROOT, "CLAUDE.md");
+  const claudeMd = join51(ROOT, "CLAUDE.md");
   const recall = writeManagedBlock(claudeMd, { body: RECALL_FIRST_BLOCK });
   if (recall.kind === "collision") {
     console.warn(
@@ -99079,15 +99832,15 @@ async function installClaudeHooks(port) {
   console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
 }
 async function installClaudeMcpConfig() {
-  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync43, writeFileSync: writeFileSync31 } = await import("node:fs");
-  const { join: join50, dirname: dirname17 } = await import("node:path");
-  const file2 = join50(ROOT, ".mcp.json");
-  const dir = dirname17(file2);
+  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync44, writeFileSync: writeFileSync32 } = await import("node:fs");
+  const { join: join51, dirname: dirname18 } = await import("node:path");
+  const file2 = join51(ROOT, ".mcp.json");
+  const dir = dirname18(file2);
   if (!existsSync41(dir)) mkdirSync13(dir, { recursive: true });
   let cfg = {};
   if (existsSync41(file2)) {
     try {
-      cfg = JSON.parse(readFileSync43(file2, "utf8"));
+      cfg = JSON.parse(readFileSync44(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -99095,21 +99848,21 @@ async function installClaudeMcpConfig() {
   }
   cfg.mcpServers ??= {};
   cfg.mcpServers["errata"] = errataMcpInvocation();
-  writeFileSync31(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  writeFileSync32(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   console.log(`installed Claude Code MCP server config \u2192 ${file2}`);
   console.log(`  Claude Code will spawn \`errata mcp\` on workspace open.`);
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses / show / similar`);
 }
 async function installCursorMcpConfig() {
-  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync43, writeFileSync: writeFileSync31 } = await import("node:fs");
-  const { join: join50 } = await import("node:path");
-  const dir = join50(ROOT, ".cursor");
+  const { mkdirSync: mkdirSync13, existsSync: existsSync41, readFileSync: readFileSync44, writeFileSync: writeFileSync32 } = await import("node:fs");
+  const { join: join51 } = await import("node:path");
+  const dir = join51(ROOT, ".cursor");
   if (!existsSync41(dir)) mkdirSync13(dir, { recursive: true });
-  const file2 = join50(dir, "mcp.json");
+  const file2 = join51(dir, "mcp.json");
   let cfg = {};
   if (existsSync41(file2)) {
     try {
-      cfg = JSON.parse(readFileSync43(file2, "utf8"));
+      cfg = JSON.parse(readFileSync44(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -99117,7 +99870,7 @@ async function installCursorMcpConfig() {
   }
   cfg.mcpServers ??= {};
   cfg.mcpServers["errata"] = errataMcpInvocation();
-  writeFileSync31(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  writeFileSync32(file2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
   console.log(`installed Cursor MCP server config \u2192 ${file2}`);
   console.log(`  Cursor will spawn \`errata mcp\` on workspace open.`);
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses`);
@@ -99128,7 +99881,7 @@ async function installCodexHooks(port) {
   const gitRoot = nearestGitRoot(process.cwd());
   const hookRoot = gitRoot && mainCheckoutOfWorktree(gitRoot) ? gitRoot : ROOT;
   const file2 = writeCodexHooks(hookRoot, port);
-  const instructions = writeManagedBlock(join49(hookRoot, "AGENTS.md"), {
+  const instructions = writeManagedBlock(join50(hookRoot, "AGENTS.md"), {
     body: AGENTS_POINTER_BODY,
     stable: true
   });
@@ -99574,9 +100327,9 @@ async function cmdDash(args2) {
       await yieldToLoop2();
       try {
         const items = selectDurableMemory(handle2.sharedStore, r.engine.profile, {
-          atCommit: readGitRefState(join49(r.root, ".git")).sha ?? void 0
+          atCommit: readGitRefState(join50(r.root, ".git")).sha ?? void 0
         });
-        const res = bleedRules(join49(r.root, ".claude", "rules"), items);
+        const res = bleedRules(join50(r.root, ".claude", "rules"), items);
         if (res.written || res.pruned) {
           console.log(
             `[rules:${r.entry.name}] ${res.written} collective principle(s) \u2192 .claude/rules` + (res.pruned ? `, ${res.pruned} pruned` : "")